Kenbe Dave, yon devlopè ki te resevwa kontrè a pou alèz lanfwa nan otèl la paske li te non an nan CEO la. Dave pa janm te wè yon sistèm alèz lanfwa anvan, men li te jis fini yon pwojè sèvis kliyan kote "apèl telefòn pèsonèl ogmante angaje pa 847%!" Se konsa, natirèlman, Dave panse: "Alèz lanfwa se jis sèvis kliyan pou enspeksyon! " Rezonasyon l ': "Quand maman mwen rele m 'dirèkteman, mwen toujou reponn. Lè gen kèk alèt jenerik ap desann, mwen asume li se yon alèt machin ak ignore li. Touche pèsonèl se kle! " Etap 1 - Kominikasyon Point-to-Point (Fiasko nan Telefòn Apèl) Yon solisyon brilliant Dave a? Lè kou se detekte, sistèm la rele chak chanm nan otèl la. Room 237 resevwa yon apèl: "Hi, gen fòm nan kwizin an, tanpri evakye." Room 301: "Hi, gen fòm nan kwizin an, tanpri evakye." Tout 847 chanm, youn pa youn. Dave se plezi - tout moun jwenn mesaj la! Men, isit la se kote li devlope. Ki sa ki rive lè gen yon ti fi grès nan kwizin ak fòm nan garaj la? Sistèm la Dave rele chanm 237: "Hi, gen fòm nan kwizin la." Lè sa a, imedyatman: "Hi, gen fòm nan garaj la." Inivèsite a se konfòtab - ki enstriksyon? Ki sa ki te pase? Klike sou Nan mitan sa a, chanm 512 gen yon envite ki se sourd. chanm 623 tcheke deyò èdtan de sa, men telefòn la kontinye sonje. chanm 108 gen yon ti bebe dormant ki gen fanmi yo se kounye a furi. Apre twazyèm alèt false nan yon semèn, envite yo kòmanse dekonekte telefòn yo. Sa a se klasik pwen-a-pwen kominikasyon - yon transmetè, yon reseptè, repete 847 fwa. Li pa ankouraje, li se pa efikas, epi li ankouraje tout moun ki gen rapò. Enspektè a fireman ap parèt: "Dave, ou pa ka fè sa a. Instale yon alèt fireman nòmal." Dave relaksman respekte. Etap 2: Kominikasyon Broadcast (Nuclear opsyon an) Men, Dave te aprann soti nan erè li yo. "Mwen gen yon lide pi bon!" li anonse. Dave enstale yon masiv alèt fire alarm ki eksplode atravè tout otèl la. Siksè! Tout moun tande li! Men, Lè sa a, Dave realize sistèm sa a se PERFÈD pou anons. Pòl la fèmen? ALARM FIRE. Breakfast fini nan 10 minit? ALARM FIRE. Lose timoun nan lobby la? ALARM FIRE. Kou yoga kòmanse? ALARM FIRE. Vwayajè yo se kounye a evakye pou alèt manje kontinan. Depatman an defi a te rele 47 fwa nan semèn sa a. Yon moun te eseye tcheke deyò deyò a defi a. Sa a se difizyon kominikasyon - yon mesaj pou tout moun, si yo vle li oswa pa. Li se tankou lè l sèvi avèk yon sistèm difizyon avanse tout vil la anonse vann garaj ou a. Etap 3: Dave jwenn yon bagay revolisyonèl Tès twazyèm Dave a: "Ki sa si nou te gen diferan intercoms pou zòn diferan?" Li enstale speaker atravè otèl la men kab yo nan chanèl separe: Swimming Pool Area Intercom: "Pwòch la fèmen nan 10 minit, sèvis tiyo fini" Restoran Intercom: "Happy èdtan kòmanse, manje ap fèmen byen vit" Konferans chanm Intercom: "Zòn reyinyon B se disponib, Wi-Fi parayj chanje" Spa Intercom: "Masaje randevou disponib, mantalye sauna nan 3pm" Pwodwi espesifik Intercoms: "Kouti nan pi wout la 3, aparèy frèt nan pi wout la 7" Vwayajè natirèlman sove nan intercoms nan zòn yo yo reyèlman sèvi ak. Vwayajè pisin tande ajou pisin, diner restoran jwenn enfòmasyon manje, patisipan konferans jwenn anons chanm reyinyon. Ki sa ki nan reyèlman te bati Dave: Publish-Subscribe (Pub/Sub) Pa konprann li, Dave kreye yon - youn nan modèl ki pi enpòtan nan estrikti lojisyèl modèn. publish-subscribe system Isit la se ki jan li travay: Editè (personèl otèl la) voye mesaj nan tèm spesifik oswa chanèl (aktualizasyon pisin, nouvèl restoran, elatriye) abonnés (vizitè) chwazi sa yo tèm yo vle koute Piblikatè pa konnen ki moun ki koute, abonnés pa konnen ki moun ki voye - yo se konplètman dekonekte Sa a se N×M kominikasyon: anpil piblisite ka voye nan anpil abonnés, men li se òganize ak filtre. Pa gen plis zwazo, pa gen plis mesaj manke, pa gen plis rele chak chanm separe. Ki sa ki enpòtan pou kòd ou Dave aksidan bati twa modèl fonksyonèl mesaj: : Koneksyon dirèkteman ant sèvis. Pa ankouraje lè ou bezwen anonse plizyè sistèm. Point-to-Point : Yon mesaj pou tout moun. Krea zwazo ak koneksyon strik. Broadcast : Publishers voye mesaj nan tèm / chanèl, abonnés chwazi sa yo koute. Scalable, dekonekte, ak efikas. Pub/Sub Nan sistèm reyèl, pub / sub solisyon pwoblèm yo menm ki Dave te fè fas ak: E-komès: Ajou envantè ale nan plizyè sèvis (rekomandasyon, analiz, notifications) san yo pa sèvis envantè konnen ki moun ki koute Chat apps: Mesaj pibliye nan chanèl, itilizatè abònman nan konvèsasyon yo yo nan Microservices: Sèvis pibliye evènman ( itilizatè ki anrejistre, lòd konplete) ke lòt sèvis ka reponn indépendamment Kreye pwòp ou Pub / Sub sistèm (Li se pi fasil pase ou panse) Pub / sub pa ta dwe intimidant. Eseye bati yon sistèm-klas pwodiksyon ke Dave ta dwe fier nan: from collections import defaultdict from typing import Dict, List, Callable class HotelPubSub: def __init__(self): self.channels: Dict[str, List[Callable]] = defaultdict(list) def subscribe(self, channel: str, callback: Callable): """Guest subscribes to hotel updates""" self.channels[channel].append(callback) print(f"Subscribed to {channel}") def publish(self, channel: str, message: str): """Hotel staff publishes updates""" if channel in self.channels: for callback in self.channels[channel]: callback(message) print(f"Published to {channel}: {message}") # Dave's hotel in action hotel = HotelPubSub() # Guests subscribe to what they care about def pool_guest(msg): print(f"🏊 Pool Guest: {msg}") def restaurant_guest(msg): print(f"🍽️ Restaurant Guest: {msg}") hotel.subscribe("pool", pool_guest) hotel.subscribe("restaurant", restaurant_guest) # Hotel publishes updates hotel.publish("pool", "Pool closing in 10 minutes!") hotel.publish("restaurant", "Happy hour starts now!") Yon sistèm pub / sous ki travay nan 20 liy. Optimizasyon ak Async Queues Men, ki sa si otèl la nan Dave vin REyèlman travay? Vèsyon an senp nou an bloke piblisite lè abonnés yo se lontan. Eske nou ajoute kouvèti: import asyncio from asyncio import Queue from collections import defaultdict class AsyncPubSub: def __init__(self): self.channels = defaultdict(list) self.message_queue = Queue() # Start background worker asyncio.create_task(self._worker()) def subscribe(self, channel: str, callback): self.channels[channel].append(callback) async def publish(self, channel: str, message: str): # Non-blocking publish - just queue it await self.message_queue.put((channel, message)) async def _worker(self): # Background worker processes messages while True: channel, message = await self.message_queue.get() if channel in self.channels: # Run all subscribers in parallel tasks = [callback(message) for callback in self.channels[channel]] await asyncio.gather(*tasks, return_exceptions=True) # Dave's async hotel in action async def demo(): hotel = AsyncPubSub() # Fast and slow subscribers async def fast_guest(msg): await asyncio.sleep(0.1) # Quick processing print(f"🏊 Fast: {msg}") async def slow_guest(msg): await asyncio.sleep(2.5) # Simulate slow database write print(f"🍽️ Slow: {msg}") hotel.subscribe("updates", fast_guest) hotel.subscribe("updates", slow_guest) # Publishers don't wait for slow subscribers await hotel.publish("updates", "Pool closing!") await hotel.publish("updates", "Happy hour!") await asyncio.sleep(0.2) # Let everything finish # asyncio.run(demo()) Koulye a, piblisite pa janm bloke - yo jis ranpli mesaj yo epi yo kontinye ale. Anplwaye a background trete livrezon nan tout abonnés nan paralèl. Abonnés vit jwenn mesaj yo byen vit (0,1s), pandan y ap lent yo pran tan yo (2.5s), men pa bloke lòt moun. Easy pèfòmans Hack: uvloop sistèm asynchon Dave a ap travay gwo, men Lè sa a, li dekouvri yon bagay magik: chanje yon sèl liy kòd ka fè tout bagay 2-4x pi vit. Dave panse sa a se klèman trè bon yo dwe vre, men deside eseye li nan tout fason. Enter nan - yon ranplase drop-in pou Python a default sik evènman ki te ekri nan Cython ak ki baze sou libuv (tou menm bagay ki fè Node.js vit). uvloop import uvloop import asyncio from collections import defaultdict import time # The magic line that makes Dave's hotel 2-4x faster asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) class TurboHotelPubSub: def __init__(self, max_queue_size=10000): self.channels = defaultdict(list) self.message_queue = asyncio.Queue(maxsize=max_queue_size) self.running = True self.performance_metrics = { 'messages_per_second': 0, 'avg_latency_ms': 0, 'active_subscribers': 0 } # Start background worker and metrics collector asyncio.create_task(self._worker()) asyncio.create_task(self._metrics_collector()) def subscribe(self, channel: str, callback): self.channels[channel].append(callback) self.performance_metrics['active_subscribers'] = sum(len(subs) for subs in self.channels.values()) print(f"Subscribed to {channel} (Total subscribers: {self.performance_metrics['active_subscribers']})") async def publish(self, channel: str, message: str): timestamp = time.time() message_with_timestamp = (channel, message, timestamp) try: self.message_queue.put_nowait(message_with_timestamp) except asyncio.QueueFull: # Backpressure - with uvloop, this is much faster await self.message_queue.put(message_with_timestamp) async def _worker(self): """Background worker - uvloop makes this significantly faster""" while self.running: channel, message, publish_time = await self.message_queue.get() # Measure end-to-end latency processing_start = time.time() if channel in self.channels: # uvloop excels at handling many concurrent tasks tasks = [] for callback in self.channels[channel]: if asyncio.iscoroutinefunction(callback): tasks.append(callback(message)) else: # uvloop's thread pool is much more efficient tasks.append(asyncio.get_event_loop().run_in_executor(None, callback, message)) # uvloop's gather is optimized for many concurrent operations await asyncio.gather(*tasks, return_exceptions=True) # Track latency total_latency = (time.time() - publish_time) * 1000 # Convert to ms self.performance_metrics['avg_latency_ms'] = ( self.performance_metrics['avg_latency_ms'] * 0.9 + total_latency * 0.1 ) self.message_queue.task_done() async def _metrics_collector(self): """Track messages per second - uvloop's timer precision helps here""" last_time = time.time() last_count = 0 while self.running: await asyncio.sleep(1) current_time = time.time() # In uvloop, queue.qsize() is more accurate and faster current_count = getattr(self.message_queue, '_finished', 0) if current_time - last_time >= 1: messages_processed = current_count - last_count self.performance_metrics['messages_per_second'] = messages_processed last_time, last_count = current_time, current_count def get_performance_stats(self): return self.performance_metrics.copy() # Dave's hotel with uvloop superpowers async def benchmark_uvloop_vs_standard(): """Demonstrate uvloop performance improvements""" # Simulate I/O-heavy subscribers (database writes, API calls) async def database_subscriber(msg): # Simulate database write await asyncio.sleep(0.001) # 1ms "database" call return f"DB: {msg}" async def api_subscriber(msg): # Simulate API call await asyncio.sleep(0.002) # 2ms "API" call return f"API: {msg}" def analytics_subscriber(msg): # Simulate CPU-heavy sync work time.sleep(0.0005) # 0.5ms CPU work return f"Analytics: {msg}" hotel = TurboHotelPubSub() # Subscribe multiple handlers to same channel for i in range(10): # 10 database subscribers hotel.subscribe("orders", database_subscriber) for i in range(5): # 5 API subscribers hotel.subscribe("orders", api_subscriber) for i in range(20): # 20 analytics subscribers hotel.subscribe("orders", analytics_subscriber) print("Starting benchmark with uvloop...") start_time = time.time() # Publish lots of messages for i in range(1000): await hotel.publish("orders", f"Order #{i}") # Wait for processing to complete await hotel.message_queue.join() end_time = time.time() stats = hotel.get_performance_stats() print(f"Benchmark complete in {end_time - start_time:.2f} seconds") print(f"Performance stats: {stats}") print(f"Total subscriber callbacks: {stats['active_subscribers'] * 1000:,}") return end_time - start_time # Uncomment to run benchmark # asyncio.run(benchmark_uvloop_vs_standard()) What uvloop supercharges: 1. I/O-Heavy Subscribers (2-4x speedup) Database ekri, apèl API, operasyon dosye Implemantasyon ki baze sou libuv nan uvloop trete dè milye de operasyon I / O kounye a pi efikasman Otèl la nan Dave ka kounye a sove mons Henderson nan Cloud diary la UPLOADS ak mons Peterson Instagram posts simultan 2. Many Concurrent Subscribers (1.5-2x speedup) Sistèm ak dè santèn oswa dè santèn de abonnés pou chak chanèl Optimize planifikasyon travay nan uvloop diminye overhead Ideyal pou sant konvansyon Dave a ak 500 + abonnés notification chanm 3. Thread Pool Operations (30-50% improvement) Sync apèl ki transfere nan thread pools jwenti jwenti jwenti jwenti jwenti jwenti se pi efikas Pi bon pou sistèm legacy Dave a ki pa ka fè async 4. Timer and Queue Precision Pi presizyon timing pou metrik ak limite pousantaj Pi bon kontwole pèfòmans chèz Ayide Dave kontwole si sistèm li a se alantou demann Real-world uvloop impact for Dave's hotel: # Before uvloop: 15,000 notifications/second # After uvloop: 35,000 notifications/second # Same code, 2.3x faster! Pi bon pati? Dave ap detèmine pa aksidan ke pafwa optimizasyon yo pi bon yo se moun ki mande pou pi piti travay. Zero code changes Reaksyon Dave: "Wait, li se? Mwen jis enpòte uvloop ak tout bagay vin pi vit? Sa a santi tankou trankilite!" Narrateur: Li pa trete, Dave. Li se jis yon bon enjenyè. When uvloop matters most: segondè abonnés kantite: 100 + abonnés pou chak chanèl I / O-heavy callbacks: Database ekri, API apèl, operasyon dosye Workloads konbine: Yon konbinezon nan abonnés vit ak lontan Latency-sensitive: Lè chak milisekond nan konte Pandan ke uvloop fè asyncio pi vit, kèk devlopè prefere Trio pou sistèm konplèks ak milye de travay ko-konkuran. Konstriksyon konkonvansyon nan Trio a ak manyen backpressure entegre ka pi konfidansyèl anba chaj ekstrèm - li fèt pou fè mal graceously anvan mistèkleman kouvri lè ou gen 10,000 + operasyon simultan. Pou otèl la Dave a, asyncio +uvloop se pafè. Pou antrepriz la pwochen Dave a (yon sistèm komès reyèl pou komodite anba dlo), Trio ta ka anpeche kèk sesyon debugging 3am. A note about Trio: Dave eseye enstale uvloop epi li vin konfòte pa mesaj erè. Isit la se bagay la - uvloop mande pou kompilasyon, se konsa ou bezwen zouti devlopman enstale. Sou Ubuntu / Debian: Sou macOS ak Homebrew: Sou Windows ... byen, Dave deside kenbe ak sikonstans estanda sou Windows ak deplwaye nan Linux nan pwodiksyon. Pafwa wout la nan rezistans ki pi piti se chwa a kòrèk. The uvloop installation gotcha: apt-get install build-essential brew install python3-dev Going Nuclear: Memory-Mapped Pub / Sub Pou pèfòmans ekstrèm oswa senaryo miltip pwosesis, nou ka sèvi ak memwa pataje ak jere abonnés konplè: import mmap import struct import multiprocessing import threading import time from collections import defaultdict from typing import Callable, Dict, List class MemoryMappedPubSub: def __init__(self, buffer_size=1024*1024): # 1MB buffer # Create shared memory buffer self.buffer_size = buffer_size self.shared_file = f'/tmp/pubsub_{multiprocessing.current_process().pid}' # Initialize memory-mapped file with open(self.shared_file, 'wb') as f: f.write(b'\x00' * buffer_size) self.mmap = mmap.mmap(open(self.shared_file, 'r+b').fileno(), 0) # Layout: [head_pos][tail_pos][message_data...] self.head_offset = 0 self.tail_offset = 8 self.data_offset = 16 # Subscriber management self.subscribers: Dict[str, List[Callable]] = defaultdict(list) self.listening = False self.listener_thread = None def subscribe(self, channel: str, callback: Callable): """Subscribe to a channel with a callback function""" self.subscribers[channel].append(callback) print(f"Subscribed to channel: {channel}") # Start listener if not already running if not self.listening: self.start_listening() def start_listening(self): """Start background thread to listen for messages""" if self.listening: return self.listening = True self.listener_thread = threading.Thread(target=self._listen_loop, daemon=True) self.listener_thread.start() print("Started listening for messages...") def stop_listening(self): """Stop the message listener""" self.listening = False if self.listener_thread: self.listener_thread.join() def _listen_loop(self): """Background loop that processes incoming messages""" while self.listening: messages = self.read_messages() for message in messages: self._process_message(message) time.sleep(0.001) # Small delay to prevent excessive CPU usage def _process_message(self, message: str): """Process a single message and notify subscribers""" try: if ':' in message: channel, content = message.split(':', 1) if channel in self.subscribers: for callback in self.subscribers[channel]: try: callback(content) except Exception as e: print(f"Error in callback for channel {channel}: {e}") except Exception as e: print(f"Error processing message: {e}") def publish(self, channel: str, message: str): """Ultra-fast direct memory write""" data = f"{channel}:{message}".encode() # Get current tail position tail = struct.unpack('Q', self.mmap[self.tail_offset:self.tail_offset+8])[0] # Check if we have enough space (simple wraparound) available_space = self.buffer_size - self.data_offset - tail if available_space < len(data) + 4: # Reset to beginning if we're near the end tail = 0 # Write message length + data struct.pack_into('I', self.mmap, self.data_offset + tail, len(data)) self.mmap[self.data_offset + tail + 4:self.data_offset + tail + 4 + len(data)] = data # Update tail pointer new_tail = tail + 4 + len(data) struct.pack_into('Q', self.mmap, self.tail_offset, new_tail) def read_messages(self): """Ultra-fast direct memory read""" head = struct.unpack('Q', self.mmap[self.head_offset:self.head_offset+8])[0] tail = struct.unpack('Q', self.mmap[self.tail_offset:self.tail_offset+8])[0] messages = [] current = head while current < tail: try: # Read message length msg_len = struct.unpack('I', self.mmap[self.data_offset + current:self.data_offset + current + 4])[0] # Safety check if msg_len > self.buffer_size or msg_len <= 0: break # Read message data data = self.mmap[self.data_offset + current + 4:self.data_offset + current + 4 + msg_len] messages.append(data.decode()) current += 4 + msg_len except Exception as e: print(f"Error reading message: {e}") break # Update head pointer struct.pack_into('Q', self.mmap, self.head_offset, current) return messages def __del__(self): """Cleanup when object is destroyed""" self.stop_listening() if hasattr(self, 'mmap'): self.mmap.close() # Dave's ultra-fast hotel messaging in action hotel = MemoryMappedPubSub() # Define subscriber callbacks def pool_guest(message): print(f"🏊 Pool Guest received: {message}") def restaurant_guest(message): print(f"🍽️ Restaurant Guest received: {message}") # Subscribe to channels (automatically starts background listener) hotel.subscribe("pool", pool_guest) hotel.subscribe("restaurant", restaurant_guest) # Publish messages (ultra-fast memory writes) hotel.publish("pool", "Pool closing in 10 minutes!") hotel.publish("restaurant", "Happy hour starts now!") What makes this special: Ultra vit pibliye: Direct memwa ekri, pa gen okenn apèl sistèm Routing Mesaj Otomatik: Background thread pwosesis mesaj ak rele abonnés Plis abonnés pou chak chanèl: chak chanèl ka gen plizyè lektè Isolasyon erè: Yon rele mal pa crash sistèm la Manadjè Resous Limyè: Otomatik netwaye lè fè Vèsyon an memwa-maped bay ou entèfas la pub / sub ak pèfòmans enterprise-grade. Hotel Dave a kounye a ka trete dè milyon de alèt vizitè pou chak sekondè pandan y ap kenbe modèl la senp "subscribe and forget" ki te fè sistèm li pi popilè. Konpare pèfòmans Solution Messages/Second Use Case Complexity Basic Pub/Sub ~50K Small apps, prototypes ⭐ Simple Queued Pub/Sub ~200K Most production systems ⭐⭐ Moderate Memory-Mapped ~5M+ High-frequency trading, multi-process ⭐⭐⭐⭐⭐ Expert External (Redis) ~100K+ Distributed systems ⭐⭐⭐ Moderate Basic Pub/Sub 50k nan Petèt aplikasyon, prototip Simpleman Queued Pub/Sub 200k nan Pifò sistèm pwodiksyon ⭐⭐ Modere Memory-Mapped ~ 5m + High frequency komès, multi-proses ️️️️ External (Redis) ~ 100k + nan Distribye sistèm ⭐⭐⭐ Modere When to use each: Basic: aprantisaj, pwojè ti, <10K mesaj / sek Kou: Pifò aplikasyon reyèl, sove trafik piki byen Memory-Mapped: > 500K mesaj / sek, kominikasyon atravè pwosesis, ultra ki ba latans Eksteryè: Sèvè miltip, persistans, pwouve fiabilite Ajoute manyen erè, persistans, ak skalasyon, epi ou gen rapò messaging klas antrepriz. Popilè Pub / Sub Teknoloji Redis Pub/Sub: Senp, vit, gwo pou karakteristik tan reyèl Apache Kafka: Enterprise-grade, k ap travay ak masiv pase RabbitMQ: Sèvi ak mesaj konfyans ak routaj fleksib Solisyon Cloud: AWS SNS / SQS, Google Pub / Sub, Azure Service Bus Final nan istwa a nan Dave Sis mwa apre sa, Dave se pwomosyon nan "Chief Communication Innovation Officer" paske bon jan kalite satisfaksyon nan kliyan yo se atravè kat la. Otèl la se kounye a pi popilè pou "sistèm mesaj revolisyonèl li yo." Dave toujou panse "kanèl" refere a sistèm televizyon kab nan otèl la, men zòn intercom li yo anseye elèv syans òdinatè atravè lemond ki jan modèl mesaj travay. Menm yon orè parèt se dwa fwa nan yon jou, e menm Dave ka plonje nan arsitektur bon si li ranplase ase bagay an premye. Li te tounen nan sa ki li konnen pi byen - sistèm transpò. nouvo antrepriz li se revolisyon nan transpò piblik anba dlo ak "Submarines Piblik" ki kouri sou "Data Bus". And what about Dave? Nan yon kesyon sou estrikti teknik, Dave enteresan eksplike: "Chak sub pibliye kote li nan pasaje ki abònman pou wout espesifik yo. Li se pub / sub, men pou sub! Epi nan plas nan motè regilye, yo se kondwi pa bus done - ou konnen, pou maksimòm pase!" Depatman an transpò vil la toujou ap eseye konprann si li se yon geni oswa si yo bezwen retire lisans biznis l '. Dave rete konvèti ke li se solisyon "problèm la nan dènye mil pou navigatè dlo." Dave te tèlman ankouraje pa siksè a nan nouvo sistèm l 'yo ke li te branche soti ak te kòmanse yon nouvo biznis. Pandan ke pwochen fwa ou se nan ti bouk la wotasyon lokal ou a, ou ta ka wè nouvo "Pub Sub" - ki prezante revolisyonèl Dave a "asynchronously pwosesis sandwiches submarine atik ak non-blockering kouche envantè." Kou a monte nan chalè cho pou "optimal mesaj persistance," ak Dave insiste sou manje a souki se an reyalite "fouj-anpeche pou pi bon pase." Li toujou resevwa kat Nwèl soti nan kliyan otèl la.
