标签：#ha

Introdução A visão original de Kay para OOP não era "objetos com dados públicos que outros manipulam", era objetos que trocam mensagens e decidem sozinhos o que fazer com elas. é Tell dont ask é basicasmente um resgate dessa ideia original, porquer com o tempo muita gente passou a usar OOP como “structs com getters e setters”, pedendo o encapsulamento de verdade. Ideia Central Exemplo do Cliente e Carteira Ask Eu PERGUNTO o saldo, e EU decido o que fazer com ele if ( cliente . carteira . saldo >= 50 ) { cliente . carteira . saldo -= 50 ; } else { console . log ( "saldo insuficiente" ); } Tell Eu DIGO pro cliente pagar, e ELE decide o que faze // "Tell" — eu DIGO pro cliente pagar, e ELE decide o que fazer cliente . pagar ( 50 ); class Cliente { carteira : Carteira ; pagar ( valor : number ) { if ( this . carteira . saldo < valor ) { throw new Error ( "saldo insuficiente" ); } this . carteira . saldo -= valor ; } } Repare a diferença de responsabilidade: No "Ask", quem chama o código precisa saber a regra ("se o saldo for menor, não pode pagar") e tomar a decisão sozinho. No "Tell", o próprio objeto conhece sua regra e decide por dentro. Quem chama só diz o que quer que aconteça. Por que "perguntar" é perigoso Pensa no "Ask" espalhado pelo sistema: toda tela, todo botão, todo endpoint que cobra do cliente vai ter que copiar essa mesma verificação de saldo: if ( cliente . carteira . saldo >= valorDoCarrinho ) { ... } if ( cliente . carteira . saldo >= valorDaAssinatura ) { ... } if ( cliente . carteira . saldo >= valorDoBoleto ) { ... } Se um dia a regra mudar (por exemplo, "clientes VIP podem ficar com saldo negativo até -R$100"), você precisa caçar todos esses lugares e mudar um por um. É praticamente garantido que algum lugar vai ser esquecido — e aí seu sistema tem um bug de regra de negócio inconsistente. Com "Tell", a regra mora em um lugar só ( Cliente.pagar ). Mudar uma vez, resolve todo o sistema. Como isso conecta com Law of Demeter Os dois princípios andam

How machine learning supports aircraft maintenance using operational data. Key Takeaways Predictive maintenance estimates component health before failure. Data quality determines model performance. Explainable models support maintenance decisions. Human review remains part of every maintenance action. Model performance requires continuous validation. Introduction Aircraft produce large volumes of operational data. Machine learning converts this data into maintenance support inspection planning and fault detection. What Is Predictive Maintenance? Predictive maintenance estimates the condition of aircraft components using historical and real-time data. The goal is to identify early signs of degradation before a failure affects operations. Traditional maintenance often follows fixed inspection intervals. Data-driven maintenance adds condition-based recommendations using operational evidence. Data Sources Model quality depends on reliable data. Common sources include: Engine sensor readings Flight data recorder information Maintenance records Aircraft utilization history Environmental conditions Component replacement history Incomplete or inaccurate data reduces prediction accuracy. Machine Learning Workflow A typical workflow includes: Collect operational and maintenance data. Remove errors and missing values. Create features from sensor measurements. Train the prediction model. Validate performance using unseen data. Monitor prediction accuracy after deployment. Retrain the model as new data becomes available. Model Selection Different problems require different algorithms. Common choices include: Random Forest XGBoost LightGBM Support Vector Machine Long Short-Term Memory (LSTM) Transformer-based time-series models Model selection depends on the prediction task, dataset size, and operational requirements. Engineering Challenges Data Quality Sensor failures, missing records, and inconsistent maintenance logs reduce model reliability. Class Imbalance Aircraft failures

In 1898, years before radio broadcasting existed and decades before anyone used the word "electronics," Nikola Tesla stood in front of a crowd at Madison Square Garden and did something that looked like magic. In a large pool of water sat a small iron-hulled boat. With no wires connecting them, Tesla sent commands through the air and the boat obeyed, turning, stopping, and blinking its lights on demand. Spectators were so unprepared for the idea that some accused him of hiding a trained monkey inside the hull, or of controlling it with his mind. What Tesla had actually built was the first wireless remote control, and it is the direct ancestor of every connected device we make today. A machine that took commands through the air Tesla called his invention a "teleautomaton," from the Greek for "remote" and "self-acting." The boat carried a radio receiver, a set of relays, and a battery driving its motor and rudder. From a control box on the side of the pool, Tesla transmitted radio signals that the receiver decoded into physical actions. Press a control, and a coherer-based circuit closed a relay, which in turn stepped the boat's steering and switching mechanism to a new position. The patent behind the demonstration, US Patent 613,809, "Method of and Apparatus for Controlling Mechanism of Moving Vessels or Vehicles," was granted in November 1898. Read today, it is startling how modern the thinking is. Tesla was not just wiggling a boat around a pool for show; he was describing a general system for sending control signals to a remote machine and having that machine act on them without a human physically present. That is the exact problem statement behind modern IoT , just with vacuum-era hardware. Why nobody knew what to do with it Tesla saw enormous potential. He imagined remotely piloted vessels, automated vehicles, and machines that could carry out instructions from miles away. He even pitched the concept to the US military as a radio-controlled torpedo. The receptio

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry . Copilot started whispering random letters into my ear, like it was leaking secret tokens from the underworld! Cute, but also, a bug! This sounds like a classic data serialization or sanitization failure in the text-to-speech (TTS) pipeline. What is happening here is a classic disconnect between the UI layer (what you see on screen) and the data payload sent to the background engine. When you read a response on screen, the Android app renders clean Markdown or HTML. However, when you tap "Read Aloud," the app has to strip away all background formatting, structural code, and system metadata, converting the response into a raw, clean string of text before handing it off to the mobile TTS engine. In this case, the background script running the relay is failing to sanitize that data stream. It is accidentally passing raw control characters, escape sequences, or hidden system tracking tokens (like structural delimiters or character-encoding artifacts) directly into the text pipeline. Because the mobile TTS engine doesn't understand that these symbols are meant to be ignored structural code, it tries to do exactly what it’s programmed to do: it reads them literally. When the voice engine encounters unexpected symbols, raw strings of characters, or broken text boundaries in the middle of a sentence, it completely disrupts the engine's predictive text processing: ● Pitch and Speed Fluctuations: Mobile TTS engines use deep learning models to predict natural tone, cadence, and inflection based on context. Injecting random, non-linguistic characters completely derails the engine's context window, causing it to panic-adjust its pitch, speed, and emphasis mid-sentence. ● Mispronunciations: The hidden characters slice words in half semantically, forcing the engine to mispronounce standard words because it's trying to blend them with the rogue data trailing right behind them. Here is a direct, high-s