माइक्रोफ़ॉर्म्स डिफ़ॉल्ट "अनुचित तंत्र" रचना बन गए हैं.
यदि आप परिपक्व होना चाहते हैं, तो आप सेवा के बारे में बात करते हैं, अवसरों के बारे में, वितरित बसों, और "इनस्टेबलता." यदि आप विज्ञापन को तैयार देखना चाहते हैं, तो आप बक्से खींच लेते हैं जब तक कि आरेख एक सफेदबोर्ड में एक कप की तरह दिखता है।
लेकिन यहाँ सही सबसे अच्छा व्यवहार वाला है
माइक्रोस्कोप एक अनुप्रयोग डिजाइन को उन्नत नहीं कर रहे हैं. वे एक संगठनीय स्केलिंग योजना हैं.
अगर आप पहले से ही संगठनीय दर्द नहीं है वे हल करते हैं, उन्हें लेने से आप भविष्य की प्रतिलिपि नहीं बना देते हैं. यह आप वर्तमान टूटी हुई वस्तुओं को प्रस्तुत करता है.
यह एक स्वाभाविक तर्क नहीं है. यह एक इंजीनियरिंग व्यापार समाप्त है, और सभी व्यापार समाप्त की तरह, यह केवल समझ लेता है जब आप कर समझते हैं और आप वापस आ रहे हैं.
मैं एक दोषी के रूप में किया गया है "पुष्टि" के रूप में किसी के रूप में किया गया है बिना पूरी तरह से आंतरिक शरीर को सूचित करने के लिए. यह आसान है शब्दावली में पकड़ा जाना और भूल जाना है कि असली चुनौती टीमों और सिस्टमों के पार जटिलता का पालन कर रहा है.
अंत में यह सॉफ्टवेयर इंजीनियरिंग के सबसे पुराने नमूने पर आता है: क्विकएस - इसे सरल रखना, बेवकूफ.
माइक्रोस्कोप को डिफ़ॉल्ट रचना के रूप में बेच दिया जाता है क्योंकि कहानी स्पष्ट है:
यह framing पीछे है.
माइक्रोफ़ॉर्म्स मुख्य रूप से कोड संरचना के बारे में नहीं हैं. वे बारे में हैं जो बिना बात किए क्या बदल सकते हैं, और कितनी बार कर सकते हैं.
अगर आपके पास नहीं है:
... तो आप एक संगठनीय समस्या हल नहीं कर रहे हैं. आप एक खरीद रहे हैं.
यह सच है कि दुनिया - भर में हर तरह के बक्सों का इस्तेमाल नहीं किया जा सकता ।
आपने इस आरेख को देखा है.
यह " नकल करने के लिए उदाहरण डिजाइन" नहीं है. यह एक चेतावनी लेबल है.
वे अकसर माइक्रोस्कोप को आरेखों के रूप में सिखाते हैं क्योंकि आरेखीय ज़िम्मेदारी सिखाने से ज़्यादा आसान होता है ।
महत्वपूर्ण रीग्रेटिंग यह है: कि आरेख एक लक्ष्य स्थिति नहीं है. यह एक है लागत सतह.
हर बॉक्स एक वादा है:
तीर प्रभावशाली दिखते हैं ।
क्योंकि प्रत्येक तीर है:
आप एक मंच बनाने के लिए कर रहे हैं ।
सभी गढ़ियों के फैसलों की तरह, माइक्रोस्कोप एक साथ आते हैं जटिलता कर रहा है (देखें) कोड के साथ खेल रहेः जटिलताएं कर सकते हैंफर्क यह है कि यह कर का परिसर हर सेवा सीमा, हर व्यवस्था, और हर विफलता पद्धति के पार.
वे आम तौर पर "सबसे अच्छा अभ्यास" के रूप में प्रसिद्ध हैं।
हर सेवा चाहता है:
एक टीम इस आराम से नहीं कर सकते हैं, यह माइक्रोफ़ॉर्म्स नहीं है. यह है अतिरिक्त चरणों के साथ एक वितरित.
एक सीधी - सी बात है ।
माइक्रोस्कोप में, एक "फोन" के बीच एक समझौता है:
विफलता मोड्स गुणाः
आप डिबग बग अब और नहीं डिबग करें. आप डिबग करें तंत्र कहता है.
यहाँ एक लागत है कि लगभग कभी एक माइक्रोस्कोप में चर्चा नहीं की है: सीरियलीकरण तथा द आकशीकरण (एसडी) ऊपरी.
सेवा सीमा का मतलब है:
// Monolith: direct object reference
var user = _userService.GetUser(userId); // < 1μs
var tier = user.Tier; // Memory access
// Microservices: serialize → network → deserialize
var json = JsonSerializer.Serialize(user); // ~50μs for a complex object
var bytes = Encoding.UTF8.GetBytes(json); // ~10μs
// ... send over network ...
var responseJson = await response.Content.ReadAsStringAsync(); // ~20μs
var user = JsonSerializer.Deserialize<User>(responseJson); // ~70μs
var tier = user.Tier; // Finally
पर कॉल करें, कि शुद्ध सीपीयू के ~1400s है... इससे पहले कि नेटवर्क में शामिल हो जाता है।
अब कि एक फोन श्रृंखला के पार गुणा:
5 शून्य श्रृंखला में, आप घटा रहे हैं ~1.5m सिर्फ SDe पर - और यह आशावादी JSON सीरियलीकरण है. यदि आप XML, प्रोटोकॉल का उपयोग कर रहे हैं प्रतिबिंब के साथ, या procras में, कि 2-10x के द्वारा कि गुणा कर रहे हैं.
जी हाँ, आप जैसे तकनीकों से इसे कम कर सकते हैं .नेट में JSON स्रोत पीढ़ी:
[JsonSerializable(typeof(User))]
internal partial class UserJsonContext : JsonSerializerContext { }
// ~30-40% faster than reflection-based serialization
var json = JsonSerializer.Serialize(user, UserJsonContext.Default.User);
लेकिन आप अभी भी सीरियलीकरण कर रहे हैं. आप सिर्फ कर थोड़ा सामग्री बना दिया है. एक एकल के रूप में, कर शून्य है.
मैं एक बार प्रोफाइल इस संरचना के साथ एक पता खोज प्रणाली (सभी कुल के बर्तन में):
ASP.NET API → Go Service (fan-out) → ASP.NET Search Service → Elasticsearch
सेवा में बहुत से डाटा स्रोत तथा एकgrogid परिणाम को नियंत्रित किया जा रहा है. प्रत्येक निवेदन का अर्थ था बहुत से सीरियल सीमा के पार.
एक सामान्य पता खोज के लिए कमी:
3-बैक- आउट प्रशंसकों के लिए:
हम सरड पर लगभग उतनी ही समय बिताते थे जितना कि हम वास्तविक खोज पर थे ।
कीमत अपने आप के लिए जा सेवा नहीं थी - प्रशंसक के लिए प्रयोग के लिए अर्थ बनाया गया था. कीमत था सेवा सीमाएँहर बरतन के किनारे का मतलब था, सीधे - सीधे नेटवर्क पर निशान लगाना ।
एक एकल ही प्रशंसक तर्क में:
यह खर्च:
एक एकलता में, यह लागत शून्य है. वस्तु पहले से ही स्मृति में है.
यहाँ एक आम बिक्री के राइस है: "मिरो सुधार प्रदर्शन."
यह पीछे है.
माइक्रोफ़ॉर्मेट होते हैं धीमा एक ही संसाधनों की गणना के लिए हम क्या मतलब के बारे में सटीक हो सकता है:
स्ट्राइकhaiti. kgm (q) प्रति सेकेंड को सीपीयू को कोर में रखता है:
स्केल्स (घर जोड़ने के द्वारा अधिक कुल निवेदन संभालता है):
माइक्रोफ़ॉर्म्स आपको देने देते हैं मापक स्वतंत्र.. अपनी सूची सेवा 10x संसाधनों की आवश्यकता है लेकिन अपनी उपयोगकर्ता सेवा नहीं करता है, आप उन्हें अलग से स्केल कर सकते हैं। यह मूल्यवान है जब आप इसकी जरूरत है.
लेकिन यह एक प्रदर्शन अनुकूल नहीं है. स्केलिंग रणनीतिऔर यह कर के साथ आता है.
तर्क "प्रयोगियों पैमाने बेहतर है" 2010 में और अधिक समझ बनाया जब सर्वर 4-8 कोर था.
आधुनिक सर्वरों में 3228 कोर होते हैं. एक भी मशीन पूरी तरह से मौजूदा ऑपरेशनों को पार कर सकता है.
उदाहरण के लिए, जैसे - जैसे आप पैटर्न इस्तेमाल करते हैं, वैसे - वैसे इसे इस्तेमाल कीजिए । एफीरल मार्टिस, आप कर सकते हैं:
// Process thousands of concurrent operations in a monolith
services.AddEphemeralWorkCoordinator<TranslationRequest>(
async (request, ct) => await TranslateAsync(request, ct),
new EphemeralOptions { MaxConcurrency = Environment.ProcessorCount * 4 });
// Bounded, observable, efficient concurrent processing
// No network overhead, no SerDe, no container orchestration
// Can handle 10k+ req/sec on a single machine
यह आपको देता है:
जब आप करें एक मशीन से अधिक स्केल करने की जरूरत है, आप कर सकते हैं:
आप अभी भी एक एकल लाइन चल रहे हैं. आप सिर्फ इसे कई बार तैनात किया है.
बिंदु: "अनुप्रयोग" के लिए माइक्रोस्कोप में विभाजित मत करें जब अलग हो जाए विशिष्ट अवयव के स्वतंत्र स्केलिंग बस ऑपरेशन के ऊपर की ओर ले जाता है.
माइक्रोस्कोप जटिलता को कम नहीं करते, वे इसे जला देते हैं.
"मौजूदा सेवा" को अभी भी संदर्भ की आवश्यकता है:
लोग इसे कम महत्त्व देते हैं क्योंकि आरेख इसे छुपाता है.
हर सीमा एक अनुबंध हो जाता है.
हर अनुबंध हो जाता है:
आप "सिर्फ एक साथ सब कुछ तैनात कर सकते हैं।"
यही कारण है कि पंचलाइन है: अगर आप एक साथ सब कुछ तैनात करते हैं, आप एक एकली का निर्माण किया है। बस एक बुरा एक।
शुरू में जो खर्च होता है, वह हमेशा एक जैसा होता है:
इस जहाजों उत्पाद मूल्य में से कोई भी.
और अधिकांश टीम यह करते हैं इससे पहले कि वे उत्पाद जटिलता के लायक साबित कर दिया है।
यह सबसे बड़ी गलती है: आप मूल्य भुगतान से पहले रस्म कर भुगतान करते हैंजैसे हर दिन के खड़े जो संरेखण के बिना बेकार समय बरबाद करते हैं, माइक्रोस्कोप औपचारिक रचना बन सकते हैं: सुंदर पर नज़र रखना, महँगी रखना, और वास्तव में समस्या से कनेक्ट करना जो आप हल कर रहे हैं.
इन खर्चों को एक साथ ले लो, ये गायब नहीं हैं - वे परिसर. और वे सेट करते हैं कि क्या पहले माइक्रोस्कोप की जरूरत है या नहीं.
विश्व - दर्शन
अन्य इंजीनियरों को प्रभावित करने के लिए नहीं.
आरेख संतुष्ट करने के लिए नहीं.
आप नहीं है एक मंच टीम को उचित ठहराने के लिए नहीं है.
टीम आकार और तैनाती मामले पैटर्न कैटलॉग से अधिक से अधिक है.
यह भौतिक है।
आप इसे पसंद करेंगे या नहीं ।
माइक्रोफ़ॉर्म्स ऑटोनोम नहीं बना सकते हैं. वे इसकी जरूरत है.
अधिकांश व्यवस्थाओं को एक औपचारिकता के रूप में शुरू करना चाहिए ।
ए मह्त्वपूर्ण संदेशmoltiptip for checkbox है:
इसका अर्थ है:
बिंदु हमेशा के लिए एकल रहने के लिए नहीं है। बिंदु करने के लिए है इससे पहले कि आप उन्हें दूर कर दें, उसकी सीमाओं का लाभ उठाइए.
एक एकल एकल बल जिन्हें आप हल करने के लिए कौशल का ढोंग करना सीख सकते हैं:
अगर आप एक स्वच्छ momolly नहीं बना सकते हैं, माइक्रोफ़ॉर्म्स आपको बचा नहीं सकते. वे सिर्फ गड़बड़ बांट देंगे.
सही एकल डिज़ाइन आपको देता है माइक्रोफ़ॉर्मेट फ़ैसले के लिए टालें बिना अपने आप को अंदर कर सकते हैं.
एक सबसे बढ़िया उदाहरण है गई- डाक पैटर्न - सुसंगतता और अतुल्यकालिक प्रक्रिया प्राप्त करने का एक तरीका अंदर बाद में वितरण के लिए एक शुद्ध मार्ग के साथ।
के बजाय:
// Tightly coupled synchronous code
public async Task PlaceOrder(Order order)
{
await _orderRepo.Save(order);
await _emailService.SendConfirmation(order); // Blocks on external service
await _inventoryService.Reserve(order.Items); // Blocks on another service
}
आप लिखते हैं:
// Outbox pattern: write events to a table
public async Task PlaceOrder(Order order)
{
await using var transaction = await _db.Database.BeginTransactionAsync();
// Save order
await _orderRepo.Save(order);
// Write events to outbox table (same transaction)
_db.OutboxMessages.Add(new OutboxMessage
{
EventType = "OrderPlaced",
Payload = JsonSerializer.Serialize(order),
CreatedAt = DateTime.UtcNow
});
await _db.SaveChangesAsync();
await transaction.CommitAsync();
// Background worker picks up outbox events and publishes them
}
यह आपको क्या देता है:
वह खण्डकंकर नमूना परियोजना उत्पादन में इस पैटर्न को प्रदर्शित करें:
// Mostlylucid.SegmentCommerce/Services/Queue/PostgresOutbox.cs
public class PostgresOutbox
{
public async Task PublishAsync<T>(string eventType, T payload)
{
var message = new OutboxMessage
{
EventType = eventType,
Payload = JsonSerializer.Serialize(payload),
CreatedAt = DateTime.UtcNow
};
_db.OutboxMessages.Add(message);
// Caller commits transaction
}
}
// Background service
public class OutboxProcessor : BackgroundService
{
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
var pending = await _db.OutboxMessages
.Where(m => !m.Processed)
.OrderBy(m => m.CreatedAt)
.Take(100)
.ToListAsync();
foreach (var message in pending)
{
await ProcessMessage(message);
message.Processed = true;
}
await _db.SaveChangesAsync();
await Task.Delay(1000, stoppingToken);
}
}
}
यह आज के एक सेब में दौड़ता है. जब आप पैमाने पर की जरूरत है:
आप वितरण कर कर के बिना माइक्रोफ़ॉर्म्स को तैयार किया है.
इनमें से किसी को भी वितरण की ज़रूरत नहीं है ।
इसलिए यह ज़रूरी नहीं कि हम अपने शरीर के अंगों के बारे में सोचें ।
महत्वपूर्ण सवाल यह नहीं है "क्या हम माइक्रोस्कोप का उपयोग करें?" यह है: क्या इसके फायदे ऑपरेशन के कर से भी बढ़कर हैं?
जैसे कि चयनित व्यक्ति के बीच में छोटा स्थानीय मॉडल और फ्रन्टर, यह समझ के बारे में है जहाँ जटिल रूप से काम आता है और कौन - से असफल तरीक़े आप प्रदान कर सकते हैं ।
अगर आपके कारण ये शब्द हैं मई, अंत, या भविष्य- रोधी, शायद यह एक कारण नहीं है.
चलो ठोस मिलता है. यहाँ क्या परिवर्तन जब आप एक एकल लाइन में विभाजित करते हैं.
मोनोलीथ:
public async Task<Order> PlaceOrder(OrderRequest request)
{
var user = await _userService.GetUser(request.UserId);
var inventory = await _inventoryService.CheckStock(request.Items);
var price = _pricingService.Calculate(request.Items, user.Tier);
var order = new Order { /* ... */ };
await _orderRepository.Save(order);
await _emailService.SendConfirmation(order);
return order;
}
कुल देर हो रही है: ~50ms (--staks में कॉल + 2 DBeies)
माइक्रोफ़ॉर्म्स:
public async Task<Order> PlaceOrder(OrderRequest request)
{
// HTTP call to User Service (network + TLS + serialization)
var user = await _httpClient.GetAsync<User>($"http://user-service/users/{request.UserId}");
// HTTP call to Inventory Service
var inventory = await _httpClient.PostAsync<StockResult>(
"http://inventory-service/check", request.Items);
// HTTP call to Pricing Service
var price = await _httpClient.PostAsync<PriceResult>(
"http://pricing-service/calculate",
new { items = request.Items, tier = user.Tier });
// HTTP call to Order Service
var order = await _httpClient.PostAsync<Order>(
"http://order-service/orders", request);
// Event published to message bus
await _messageBus.Publish(new OrderPlaced { OrderId = order.Id });
return order;
}
कुल लेटिएशन: ~400ms (इस पर भी आशावादी 5080ms प्रति HTTP कॉल वास्तविक वातावरण + संदेश बस को प्रकाशित करता है - ~20m)
जो कुछ तुम लोग (ख़ुदा की राह में) किया करते हो
तुमने जो भुगतान किया:
मोनोलीलीफिंग में त्रुटि:
try
{
var order = await PlaceOrder(request);
return Ok(order);
}
catch (InsufficientStockException)
{
return BadRequest(new { error = "Out of stock" });
}
catch (Exception ex)
{
_logger.LogError(ex, "Order placement failed");
return StatusCode(500);
}
माइक्रोफ़ॉर्मेट त्रुटि नियंत्रण:
try
{
// Call User Service
var user = await _httpClient.GetAsync<User>($"http://user-service/users/{request.UserId}");
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
{
return NotFound(new { error = "User not found" });
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.ServiceUnavailable)
{
// Retry with exponential backoff?
// Circuit breaker opened?
// Fail fast or degrade gracefully?
_logger.LogWarning("User service unavailable, retrying...");
await Task.Delay(TimeSpan.FromMilliseconds(100));
// ... retry logic ...
}
catch (TaskCanceledException ex)
{
// Timeout - was the request processed? Do we retry?
_logger.LogError("User service timeout");
return StatusCode(503, new { error = "Service temporarily unavailable" });
}
try
{
var inventory = await _httpClient.PostAsync<StockResult>(
"http://inventory-service/check", request.Items);
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.BadRequest)
{
// Business error from remote service
var errorDetails = await ex.Content.ReadAsAsync<ErrorResponse>();
return BadRequest(new { error = errorDetails.Message });
}
catch (HttpRequestException ex)
{
// Which service failed? Network issue? Service down?
// Do we have a fallback? Cached data? Fail fast?
_logger.LogError(ex, "Inventory service failed");
// Maybe try a backup instance?
// ... more retry logic ...
}
// And repeat for every service call...
हर नेटवर्क कॉल प्रस्तुत करता है:
मोनोली तैनाती:
# Build
dotnet publish -c Release
# Run migrations
dotnet ef database update
# Deploy
docker push myapp:v1.2.3
kubectl set image deployment/myapp myapp=myapp:v1.2.3
# Rollback if needed
kubectl rollout undo deployment/myapp
माइक्रोफ़ॉर्म्स तैनातिंग:
अब आप आदेश स्ट्रक्चर बदल रहे हैं. Order इसमें शामिल है UserTier सीधे (कार्य के लिए सामान्यीकृत).
# 1. Deploy Pricing Service v2 (understands both old and new Order format)
kubectl set image deployment/pricing-service pricing-service=pricing:v2.0.0
# 2. Wait for rollout and monitor
kubectl rollout status deployment/pricing-service
# Check metrics - is v2 working with old order format?
# 3. Deploy Order Service v2 (starts sending new format)
kubectl set image deployment/order-service order-service=order:v2.0.0
# 4. Monitor for errors
# If Pricing v2 has a bug, you can't just rollback Order service
# You have to rollback both in reverse order
# 5. Deploy User Service v2 (stops including tier in response)
# But wait - old Order Service instances might still be running!
# Need zero-downtime rollout or maintain backward compat
# 6. Eventually clean up old code paths in Pricing Service v3
# (6 months later because you're scared to remove backward compat)
माइक्रोस्कोप से, प्रत्येक परिवर्तन विभिन्न सेवाओं को पार करता है ।
लेकिन इसमें अनुशासन, साधन और अनुभव की माँग की जाती है कि अधिकांश टीम दुःख के वर्षों के बाद ही केवल लाभ उठाते हैं ।
मोनोलीर्ड बग रपट: "यारमेंट प्रीसीनियम उपयोक्ताों के लिए असफल"
// Set breakpoint in PlaceOrder
// Step through each call
// User tier is null - ah, there's the bug
// Fix, test, deploy
माइक्रोफ़ॉर्मेट बग रिपोर्ट: "यारमेंट प्रीसीनियम उपयोक्ताों के लिए असफल"
# 1. Check logs - which service failed?
kubectl logs -l app=order-service --tail=100
# 2. Oh, it's calling Pricing service. Check those logs
kubectl logs -l app=pricing-service --tail=100
# 3. Grep for correlation ID across all services
stern -l app=order-service,app=pricing-service,app=user-service \
| grep "correlation-id-xyz"
# 4. Reconstruct the call chain from distributed traces
# Open Jaeger/Zipkin, find the trace
# User service returned 200 OK
# Pricing service returned 400 Bad Request
# Error: "user.tier is required"
# 5. Check User service - did it send tier?
# Look at schema version - ah, User v1.2 stopped sending tier
# When did that deploy? Was Pricing service updated?
# 6. Check API contracts
# Pricing expects tier, User stopped sending it
# Who approved this change?
# 7. Fix requires coordinating two teams
# Can't just deploy a fix - need contract negotiation
यह सच्चाई है: बग जो 5-मिमेटिक्स सुधार थे बहु-टेम जांच हो सकता है.
यदि यह अत्यधिक, अच्छा लगता है ।
माइक्रोफ़ॉर्म्स एक ही रास्ते का दरवाज़ा हैं। एक तरह से उन्हें इलाज करें।
सुरक्षित पथ उबाऊ लगता है:
अगर आप एमिलेथ के अंदर सीमा नहीं खींच पा सकते हैं (प्रयोग योग्य निर्भरता के साथ), तो आप इसे सुरक्षित नहीं निकाल सकते.
सबसे पहले समुद्री डाकू जाओ.
पढ़ने में आसान है:
यदि अलग होने की जरूरत है तो पहले पढ़ने के मॉडल बाहर ले जाएँ.
के- एम- प्लॉट सेवा काल जंजीरों तैयार किया गया है.
आईनेप संदेश उत्पन्न करता है:
अंत की घटनाओं और तथ्यों को अलग करने के द्वारा शुरू करें, नहीं ।
कोई बड़ा बंगा.
नहीं "हम इसे ठीक से फिर से लिखना होगा।"
नाप तौल कर तौल कर देना और तौल में कमी करना।
यदि आप समझा नहीं सकते कि क्यों एक सेवा स्वतंत्र है, तो यह अस्तित्व में नहीं होना चाहिए.
वे एक परिणाम हैं ।
जटिलता का सौदा किया जाना चाहिए. वे एक ऋणी साधन नहीं हैं ।
व्यापार- ऑफ समीकरण सरल है:
Microservices Value = (Team Autonomy + Independent Scaling + Failure Isolation)
- (Latency Tax + SerDe Tax + Operational Overhead + Coordination Cost)
अधिकतर टीमों के लिए - विशेष रूप से मंच के लिए या एकल-कार उत्पादों पर अधिकार. आप लाभों के लिए बहुत लागत आप अभी तक की जरूरत नहीं है.
लेकिन जब आप हैं:
... तो बाएँ तरफ जीतने के लिए शुरू होता है. कर सही हो जाता है.
इन सवालों के क्रम में पूछिए:
क्या एक टीम अभी भी इस अंत से आगे बढ़ सकती है?
✔ जी हाँ: एक - दूसरे से अलग रहिए ।
टीमों को एक दूसरे के रिलीज चक्र से बंद कर दिया है?
✔ जी हाँ: माइक्रोस्कोप से काम करने में मदद मिल सकती है ।
हमारे पास वितरित तंत्रों को चलाने के लिए ऑपरेशन - पेशियाँ हैं?
▪ नहीं: पहले निर्माण कीजिए ।
हम ट्रेस, डिबग, और बहुत सी सेवाओं को बिना भारी कर सकते हैं?
आप तैयार नहीं हैं. हाँ: हो सकता है.
क्या हमने पहले कोड में सीमाएं सिद्ध की हैं?
जी हाँ: दूसरों के साथ अच्छा रिश्ता बनाए रखना सुरक्षित है ।
अगर आप विश्वास के साथ पिछले सवाल 3 नहीं पा सकते हैं, तो आप माइक्रोस्कोप के लिए तैयार नहीं हैं - और यह ठीक है. नाव की बनावट एक होड़ लगाने का फायदा है ।
सबसे सफल उत्पादन पहले एक ब्लैथ के रूप में बनाया गया: GiBhb, स्टैकिस, बेसकाम्प. वे केवल तब वितरित तंत्रों में उन्नति करते थे जब अंग - संबंधी पीड़ा इसकी माँग करती थी ।
आपका काम सबसे प्रभावशाली रचना का निर्माण करने के लिए नहीं है. यह मूल्य को बचाने के लिए है जब तक कि दुर्घटनात्मक जटिलताओं को कम किया जा रहा है.
और कोई ग्राहक कभी अतिरिक्त भुगतान नहीं किया है क्योंकि अपने तंत्र कायरका इस्तेमाल किया है.
कभी कभी इसका अर्थ होता है कि माइक्रोस्कोप का मतलब होता है। आम तौर पर, इसका मतलब है एक अच्छी तरह से पालन - पोषण करना और उस तरह से रखने के लिए अनुशासन।
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.