<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Roman Dvornov on Medium]]></title>
        <description><![CDATA[Stories by Roman Dvornov on Medium]]></description>
        <link>https://medium.com/@rdvornov?source=rss-ac81ad26a141------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*onX9rKWWXqvS6F_rpYzGPg.jpeg</url>
            <title>Stories by Roman Dvornov on Medium</title>
            <link>https://medium.com/@rdvornov?source=rss-ac81ad26a141------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:06:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rdvornov/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[AI and the Coming Correction]]></title>
            <link>https://medium.com/@rdvornov/ai-and-the-coming-correction-e93bb31b9476?source=rss-ac81ad26a141------2</link>
            <guid isPermaLink="false">https://medium.com/p/e93bb31b9476</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[tech-industry]]></category>
            <dc:creator><![CDATA[Roman Dvornov]]></dc:creator>
            <pubDate>Fri, 06 Mar 2026 05:18:39 GMT</pubDate>
            <atom:updated>2026-03-06T05:41:57.577Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LqGPN7M0jTu3RH7SiOD2Yw.png" /></figure><p><em>A forecast for the next year (2026)</em></p><p>I generally dislike making predictions, especially about technology. Most predictions age badly. Reality tends to ignore the clean trajectories we draw in our heads.</p><p>But the current discussion around AI feels unusual. There is an enormous amount of excitement, endless demonstrations of what models can do, and surprisingly little reflection on what all of this actually means for engineering as a discipline.</p><p>So instead of debating whether AI is good or bad, I want to do something simpler: write down a forecast. Not for the next decade, but for the next year. I might be wrong in details, but I am fairly confident about the direction.</p><h3>1. The AI euphoria phase</h3><p>Right now the industry is clearly living through a phase of technological euphoria. Engineers proudly demonstrate how a model generated hundreds of lines of code. Entire prototypes appear in minutes. Agents explore codebases, propose fixes, and assemble systems at a speed that would have been hard to imagine even a year ago.</p><p>What is largely missing from the conversation is structural thinking. Most discussions stop at the demonstration stage: the model solved the task, the prototype works, the agent generated the system. But prototypes are not systems. And demonstrations are not engineering.</p><blockquote><strong>AI is currently treated less like a tool and more like a miracle.</strong></blockquote><p>This phase is not unusual. Almost every powerful technology goes through it.</p><h3>2. The confusion between code and engineering</h3><p>One of the most common conclusions today is that engineers might soon become unnecessary. The reasoning is simple: if AI can generate code, why do we need developers? The problem is that this question confuses two very different things. Code generation and engineering are not the same activity.</p><p>Code is only one artifact produced during the lifecycle of a system. Engineering is everything around it: understanding the problem space, designing architecture, dealing with constraints, debugging complex interactions, and maintaining systems over years.</p><blockquote><strong>Generating code is not the same as building systems.</strong></blockquote><p>Automating one artifact does not automatically automate the discipline that surrounds it.</p><h3>3. The illusion of free productivity</h3><p>AI genuinely increases productivity. Anyone who works with modern models can see that. But the industry is beginning to treat this increase as if it were permanent and free.</p><p>It is neither.</p><p>Working with AI systems requires constant attention. Someone has to frame the problem, interpret the results, verify the reasoning, guide the model, and integrate its output into a real architecture. The engineer becomes less of a manual builder and more of an operator of a powerful reasoning engine.</p><blockquote><strong>AI works like an energy drink for engineering productivity.<br>The boost is real. The crash is inevitable.</strong></blockquote><h3>4. The coming wave of cognitive burnout</h3><p>One topic almost nobody discusses is the cognitive cost of this new workflow.</p><p>Interacting with AI is not passive. It demands constant context switching, evaluation, and decision making. Each response from the model requires interpretation. Each solution must be validated. This creates a feedback loop of continuous engagement. It becomes easy to spend hours inside chains of prompts and responses.</p><p>The experience can feel strangely addictive. Each prompt might produce a brilliant insight. Each iteration promises a shortcut to the next solution.</p><blockquote>But <strong>human cognitive capacity is not designed for continuous amplification.</strong></blockquote><p>My expectation is that within the next year the industry will start encountering a noticeable wave of AI-related burnout. Not because the tools are bad, but because people are trying to operate at an unsustainable level of cognitive acceleration.</p><h3>5. The disappearing engineering memory</h3><p>There is a subtler problem that may appear even earlier.</p><p>When engineers investigate systems themselves, knowledge accumulates. They read the code, follow execution paths, and gradually build an internal model of how the system behaves. That understanding becomes part of the organization’s collective expertise.</p><p>When an AI agent investigates the system instead, something different happens. The model explores the codebase, reasons about it, and proposes a solution. The reasoning process, however, mostly lives inside the temporary context of that conversation.</p><blockquote><strong>When an engineer investigates a system, the knowledge stays in their head.<br>When an agent investigates it, the knowledge often disappears with the chat.</strong></blockquote><p>Problems get solved, but organizational understanding does not necessarily grow.</p><h3>6. The erosion of deep expertise</h3><p>If this pattern continues, another effect may appear. Engineers may gradually stop building deep internal models of the systems they work with. Instead of understanding systems, they learn how to ask questions.</p><p>At first this looks like efficiency. Tasks are completed faster. But deep expertise is built through sustained engagement with complex problems.</p><blockquote><strong>Delegating reasoning is not the same as delegating work.</strong></blockquote><p>If reasoning itself is delegated too aggressively, expertise slowly erodes.</p><h3>7. The averaging effect of AI systems</h3><p>Large language models are optimized to reproduce patterns from massive corpora of existing knowledge. Their strength lies in identifying the statistical center of solutions. They reproduce best practices extremely well.</p><p>But innovation rarely begins at the statistical center. Many important ideas start as strange combinations, unusual experiments, or approaches that initially look wrong.</p><blockquote><strong>AI amplifies the average. Innovation often lives in the outliers.</strong></blockquote><p>If most engineers rely on the same models trained on the same knowledge, solutions will gradually converge.</p><blockquote><strong>Everything that can be vibe-coded will eventually be vibe-coded.</strong></blockquote><h3>8. The paradox of new knowledge</h3><p>AI systems are extraordinary tools for processing and recombining existing knowledge. But new knowledge rarely appears through recombination alone. It appears through interaction with reality: experiments, mistakes, unexpected observations.</p><p>Humans are remarkably good at producing this irregularity. We try strange ideas. We explore paths that appear pointless. Most of these attempts lead nowhere, but occasionally one of them opens a completely new direction. What we sometimes call irrational behavior is often simply exploration beyond the boundaries of the known.</p><blockquote><strong>AI accelerates execution. Humans generate experience.</strong></blockquote><p>Without that experience, systems eventually stagnate.</p><h3>Closing</h3><p>AI is probably the most powerful engineering tool introduced in decades. But powerful tools amplify everything: strengths, weaknesses, signals, and noise. Right now the industry is experiencing the amplification of excitement and productivity.</p><p>Over the next year we may begin to see something else amplified as well: fatigue, architectural noise, erosion of expertise, and the realization that generating code is not the same as building systems. When that realization arrives, the conversation around AI will likely become calmer and more mature.</p><p>And that will be the moment when the real work begins.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e93bb31b9476" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Profiling Leaves You Guessing]]></title>
            <link>https://medium.com/@rdvornov/why-profiling-leaves-you-guessing-58f36a97e36f?source=rss-ac81ad26a141------2</link>
            <guid isPermaLink="false">https://medium.com/p/58f36a97e36f</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Roman Dvornov]]></dc:creator>
            <pubDate>Sat, 17 Jan 2026 02:30:42 GMT</pubDate>
            <atom:updated>2026-01-18T21:13:41.281Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OkUhPBxOFNCPi09jD93XwQ.png" /></figure><p><em>From isolated measurements to understanding execution as a process</em></p><p>For a long time, profiling has relied on a small number of dominant views. Most often, this view is time-based: CPU samples, timelines, call trees. Other signals — memory usage, garbage collection, allocations — are projected onto that axis as aggregates, counters, or annotations.</p><p>This approach works as long as system behavior is simple and stable. But as systems grow in complexity, it increasingly produces a single-axis view that <strong>systematically fails to explain</strong> what engineers observe in practice.</p><h3>The limits of a single-axis view</h3><p>A single-axis profile answers questions like:</p><ul><li>where time was spent,</li><li>how much memory was used at a given moment,</li><li>how many bytes were allocated in total,</li><li>how much time GC took.</li></ul><p>But many real problems no longer fit into this frame. In practice, teams encounter issues that are <strong>simple to state but hard to explain</strong>:</p><ul><li>identical scenarios end with very different memory states,</li><li>regressions appear only as increased variance across runs,</li><li>GC time fluctuates dramatically without clear correlation to heap size,</li><li>small code or build changes lead to delayed and displaced performance effects.</li></ul><p>These are not edge cases. They appear in routine investigations of modern systems.</p><blockquote><em>The common pattern is that existing tools provide </em>numbers<em> and </em>aggregates<em>,<br>but fail to explain </em>process<em>.</em></blockquote><h3>Profiling as a set of projections</h3><p>CPU time and memory activity are not competing dimensions. They describe different aspects of the same execution:</p><ul><li>CPU time shows where work is performed.</li><li>Memory activity shows how state is created, transformed, and maintained.</li><li>GC behavior shows how the runtime reacts to accumulated state.</li></ul><blockquote><em>Every profiling </em><strong><em>view is a projection</em></strong><em>.</em></blockquote><p>Observed in isolation, each of these views is incomplete. Flattened into a single axis, they obscure more than they reveal.</p><p>What is missing is not another metric, but <strong>additional projections</strong>.</p><h3>Adding projections reveals structure</h3><p>When new projections are added, something important happens. Instead of a flat picture composed of aggregates, a model of the process begins to emerge. Not as a single timeline or a single tree, but as a volume:</p><ul><li>with phases,</li><li>with accumulation,</li><li>with delayed effects,</li><li>with sensitivity to history.</li></ul><p>The system stops looking like a collection of independent metrics and starts looking like a <strong>continuous process evolving over time</strong>.</p><h3>The first new projection: allocation as an event stream</h3><p>The most practical entry point into this shift is allocation behavior.</p><p>Historically, allocations were observed through sampling or aggregation. Recording every allocation was considered impractical due to sheer volume — often millions of events per second. As a result, tooling evolved around the assumption that allocation behavior must be approximated. Once this assumption is lifted, allocation becomes a dense event stream:</p><ul><li>ordered,</li><li>attributed to code locations,</li><li>carrying basic attributes (size, space, state).</li></ul><blockquote><em>This is not a matter of more detail. It is a </em><strong><em>change in regime</em></strong><em>.</em></blockquote><p>Allocation events are not just “memory data”.<br>They represent <strong>state transitions</strong> in the execution process.<br>They form a <strong>bridge between CPU activity and memory state</strong>.</p><p>Allocation is not unique by nature. It is simply the first signal dense and ubiquitous enough to make this model practical. It is chosen because it introduces <strong>entities</strong>.</p><p>Entities become nodes: objects with identity, lifetime, and origin. Write barriers, promotions, and movements are edges — transitions between states. Without nodes, transitions have nothing to attach to.</p><h3>Why record events even if we aggregate later</h3><p>A natural question arises: if analysis ultimately relies on histograms, tables, and summaries, why not aggregate during collection?</p><blockquote><em>Because </em><strong><em>aggregation is a projection</em></strong><em>.</em></blockquote><p>Each attribute of an allocation — location, size, type, space, phase, GC epoch — is a separate dimension. Aggregating early fixes the projection in advance and discards information before the investigation even begins.</p><blockquote><em>Aggregation is necessary for presentation, but </em><strong><em>dangerous as a foundation</em></strong><em>.<br>It fixes the questions that can be asked and discards information that may later prove essential.</em></blockquote><p>Keeping allocations as individual events preserves:</p><ul><li>dimensionality (relationships between attributes),</li><li>ordering (the sequence of events),</li><li>phase boundaries (how behavior changes over time),</li><li>and freedom of interpretation.</li></ul><p>Aggregation becomes a <strong>choice made during analysis</strong>, not a constraint imposed at runtime.</p><h3>Order is information</h3><blockquote><em>The sequence of events carries information that aggregated metrics cannot recover. Order turns </em><strong><em>isolated facts into behavior</em></strong><em>.</em></blockquote><p>A dense, ordered stream of allocation events anchored to stable code locations approximates execution flow in a way sampling cannot. It becomes possible to infer:</p><ul><li>approximate call frequencies,</li><li>loop iteration patterns,</li><li>phase transitions,</li><li>differences in execution paths between runs.</li></ul><p>This is not a traditional trace and not a sample.<br>It is a <strong>new class of profiling data</strong>: continuous, dense, and location-aware.<br>Such data has not previously existed in profiling <strong>at scale</strong>.</p><h3>Memory as a process, not a number</h3><p>Memory behavior is <strong>usually observed as state</strong>: how many bytes are used at a given moment. In reality, memory is a <strong>process</strong>:</p><ul><li>objects are allocated,</li><li>composed of multiple internal structures,</li><li>connected to each other,</li><li>moved, resized, promoted, and eventually collected.</li></ul><p>Garbage collection does not merely free bytes. It restructures internal state: objects, references, remembered sets, and runtime metadata. When only byte counts and snapshots are visible, GC appears unpredictable. In practice, it is reacting to unobserved structure.</p><blockquote><em>Memory metrics variability is not a noise problem.<br>It is an </em><strong><em>observability problem</em></strong><em>.</em></blockquote><h3>GC as a reaction, not a cause</h3><p>Garbage collection illustrates the limitations of flat views particularly clearly. GC time is often treated as either a performance metric or dismissed as irrelevant to memory analysis. In reality:</p><blockquote><em>GC is a reaction to the </em><strong><em>structure accumulated over time</em></strong><em>.</em></blockquote><p>The cost of a GC cycle depends not only on how much memory was allocated, but on:</p><ul><li>how objects are composed,</li><li>how they are connected,</li><li>how many survived previous epochs,</li><li>how much internal bookkeeping is required.</li></ul><p>Bookkeeping means the internal work a runtime must perform to keep memory and execution state consistent — updating references, maintaining metadata, tracking object lifetimes, and preserving invariants. This work is often <strong>invisible in byte-based metrics</strong>, yet it dominates GC cost and contributes significantly to performance variability.</p><p>Two GC cycles triggered under similar conditions can differ in cost by an order of magnitude. Tools may show this variability, but not its cause. GC appears unpredictable because the <strong>structure it operates on is not observed</strong>.</p><h3>Variability is a signal</h3><p>When results vary between runs, the usual response is to average more samples. But <strong>variability is not noise</strong>. It is a sign that the <strong>system is sensitive</strong> to execution history, phase timing, or structural differences.</p><p>Without event-level observability, this sensitivity cannot be explained. The information required to reason about it has already been discarded.</p><blockquote><em>Dense event streams do not eliminate variability.<br>They make it </em><strong><em>observable</em></strong><em>.</em></blockquote><h3>Layers, not replacements</h3><p>Dense event streams do not replace time-based profiling. CPU samples provide sparse temporal and call-stack context. Allocation events populate this frame with much denser structural information.</p><p>Different projections describe different aspects of the same process:</p><ul><li>CPU time shows where work happens;</li><li>memory events show how state evolves;</li><li>GC reflects the runtime’s response to accumulated structure.</li></ul><p>Observed together, these projections begin to form a <strong>model of system behavior</strong>.</p><h3>Beyond allocation</h3><p>Allocation happens to be the first practical signal. The model itself is not allocation-specific. Once behavior is modeled as a sequence of events, it becomes natural to consider other lifecycle transitions:</p><ul><li>movement between spaces,</li><li>resizing of backing stores,</li><li>eventually, changes in object relationships.</li></ul><p>Not all of these need to be enabled by default. The critical change is that the model allows them. Profiling is no longer limited to a small set of predefined counters. It becomes extensible along <strong>new projections</strong>.</p><h3>From flat profiles to a volume</h3><p>The shift described here is not from CPU-centric to memory-centric profiling.</p><blockquote><em>It is a shift from flat representations to </em><strong><em>multi-projection models</em></strong><em>.</em></blockquote><p>CPU time, memory activity, GC behavior, and code execution are not competing views. They are complementary projections through which the same underlying process becomes visible.</p><p>As more projections are added, the picture gains depth. A volume emerges where <strong>behavior can be explored</strong>, not guessed.</p><h3>The real shift</h3><p>The fundamental change is not a new tool or a new metric, but this:</p><blockquote>Profiling stops being a collection of <em>isolated</em> measurements and becomes a way to reconstruct the process by combining multiple projections.</blockquote><p>Recording every allocation is the entry point into this model. Everything else builds on top of it.</p><p>When profiling gains depth, <strong>systems stop looking random</strong> — not simpler, but they <strong>become observable</strong>.</p><h3>What changes in practice</h3><p>This approach does not eliminate complexity or nondeterminism.</p><blockquote><em>It removes an artificial </em><strong><em>ceiling on observability</em></strong><em>.</em></blockquote><p>Once that ceiling is gone:</p><ul><li>variance becomes explainable,</li><li>delayed effects become traceable,</li><li>regressions stop hiding behind averages,</li><li>and profiling moves from symptom tracking to process understanding.</li></ul><p>Profiling stops guessing and starts <strong>modeling behavior</strong>.<br>And once behavior can be modeled, it can be reasoned about.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58f36a97e36f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stability Comes From Tension]]></title>
            <link>https://medium.com/@rdvornov/stability-comes-from-tension-fa341c9bb719?source=rss-ac81ad26a141------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa341c9bb719</guid>
            <dc:creator><![CDATA[Roman Dvornov]]></dc:creator>
            <pubDate>Thu, 15 Jan 2026 01:28:45 GMT</pubDate>
            <atom:updated>2026-01-17T00:35:31.700Z</atom:updated>
            <content:encoded><![CDATA[<p><em>If removing tension feels like improvement, you are probably breaking something important.</em></p><p>This is not a framework.<br>Not advice.<br>Not a call for better communication or healthier conflict.</p><p>This is a simple observation that becomes uncomfortable once you take it seriously.</p><h3>We Keep Trying to Remove the Wrong Thing</h3><p>Across teams, organisations, and systems, tension is treated as a defect.</p><p>Disagreement is inefficient.<br>Friction slows execution.<br>Conflicting views feel like noise.</p><p>So we align.<br>We unify.<br>We optimise.</p><p>And for a while, everything becomes smoother.</p><p>That smoothness is usually celebrated.<br>It shouldn’t be.</p><h3>The Tension That Matters Is Not Personal</h3><p>The problem is not conflict between people.<br>People are interchangeable.</p><p>The problem is conflict between <strong>criteria</strong>.</p><p>Any system that does something non-trivial must constantly answer incompatible questions:</p><ul><li>What matters more?</li><li>What counts as success?</li><li>What is acceptable error?</li><li>What is “good enough” <em>right now</em>?</li></ul><p>When all of these questions collapse into a single answer, the system becomes coherent — and blind.</p><p>When different parts of the system answer them differently, something else happens: solutions stop being obvious, assumptions stop hiding, errors stop reinforcing themselves.</p><p>This friction is not accidental.</p><p>It is doing work.</p><h3>Comfort Is Not Neutral</h3><p>Systems often feel best right before they start drifting.</p><p>Decisions are easy.<br>Progress is fast.<br>Nothing pushes back.</p><p>What actually disappeared is not resistance — <br>it is <strong>correction</strong>.</p><p>Without incompatible perspectives applying pressure, systems do not fail loudly.<br>They stabilise around a narrow version of correctness.<br>They remain internally consistent while becoming externally wrong.</p><p>Comfort is not proof of health.<br>It is often proof that something important is no longer being questioned.</p><h3>The Pattern Is Older Than Any Method</h3><p>You can see this mechanism almost everywhere once you stop looking for it as a technique.</p><p>Science does not advance through agreement, but through incompatible explanations that cannot coexist.<br>Institutions survive because power is split, not aligned.<br>Reliable systems contain parts that evaluate outcomes differently and are allowed to disagree.</p><p>This is not inefficiency.<br>It is structural.</p><blockquote><strong><em>Stability and objectivity in complex systems emerge from the structured coexistence of conflicting evaluative perspectives.</em></strong></blockquote><p>Remove this tension and errors do not disappear.<br>They simply lose opposition.</p><h3>Why This Suddenly Matters</h3><p>For a long time, systems inherited tension automatically.</p><p>Different people.<br>Different roles.<br>Different incentives.<br>Different interpretations.</p><p>No one had to design it.</p><p>Now we increasingly build systems where:</p><ul><li>objectives are unified,</li><li>evaluation is centralised,</li><li>disagreement is optimised away,</li><li>correction is externalised or removed.</li></ul><p>Autonomous systems do not argue with themselves.<br>If conflict is not embedded, it does not exist.</p><p>What we are seeing now is not a failure of intelligence or scale.<br>It is a failure of structure.</p><h3>This Is Not a Call for Chaos</h3><p>Not all tension is useful.</p><p>Unclear responsibility is destructive.<br>Personal conflict is noise.<br>Random disagreement is not a mechanism.</p><p>The tension that matters is <strong>structured</strong>.<br>It is sustained.<br>It is not resolved.<br>It exists because the system cannot afford to collapse its criteria into one.</p><p>Designing for this feels wrong.<br>It slows things down.<br>It prevents closure.</p><p>That is the point.</p><h3>No Resolution</h3><p>Systems that eliminate tension feel better.<br>Systems that survive keep it.</p><p>If this sounds unsatisfying, it probably should.</p><p>Because stability is not something you reach.<br>It is something you hold — <br>between forces that never fully agree.</p><p>And once that tension is gone,<br>what remains may still look like a system — <br>but it is already drifting.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa341c9bb719" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Changing a way we’re viewing JSON in a browser]]></title>
            <link>https://medium.com/@rdvornov/changing-a-way-were-viewing-json-in-a-browser-51eda9103fa2?source=rss-ac81ad26a141------2</link>
            <guid isPermaLink="false">https://medium.com/p/51eda9103fa2</guid>
            <category><![CDATA[tools]]></category>
            <category><![CDATA[browser-extension]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Roman Dvornov]]></dc:creator>
            <pubDate>Tue, 23 Jul 2019 12:28:04 GMT</pubDate>
            <atom:updated>2019-07-30T10:51:24.520Z</atom:updated>
            <content:encoded><![CDATA[<h3>JsonDiscovery: Changing a way we’re viewing JSON in a browser</h3><p>Today, I would like to tell you about <a href="https://github.com/discoveryjs/browser-extension-json-discovery">JsonDiscovery</a>, a browser’s extension for viewing JSON. You‘ll probably say: “there are a lot of such extensions!”. Yeah, a lot of, but JsonDiscovery’s features make it different and really powerful.</p><p>Let’s take a closer look.</p><p>For the demos I used all-cards collection of <a href="https://github.com/pdyck/hearthstone-db">Hearthstone-DB</a> project (thanks to <a href="https://twitter.com/homyasusina">Olga Kobets</a> for an idea). And that’s how it looks like when opened in a browser with JsonDiscovery installed:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rVEsLM2EWIH3X_0PIuE4KA.png" /><figcaption>Hearthstone-DB’s <a href="https://github.com/pdyck/hearthstone-db/blob/master/cards/all-cards.json">all-cards.json</a> opened in a browser with JsonDiscovery installed</figcaption></figure><p>At first glance, it’s just one more JSON highlighter. That’s because most features are not on surface to avoid disturb you from your JSON. Let’s reveal them:</p><ul><li>Easy JSON fragment copy to clipboard</li><li>JSON structure signature</li><li>JSON transformation with a query using <a href="https://github.com/lahmatiy/jora">Jora</a></li><li>Suggestions on a query typing</li><li>Customisation of JSON data presentation</li><li>Report sharing by a link</li></ul><p>Consider each of them in details.</p><h3>JSON fragment copy to clipboard</h3><p>Sometimes you need to copy a fragment of JSON, e.g. some nested object or array. It’s easy task with JsonDiscovery, as every expanded object and array have action buttons. And one of them is “ƒ” button, with options to copy JSON in compact or pretty form:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Iy2w3hxgRq3GJL6tEl0otw.png" /><figcaption>Action menu for an expanded object or array</figcaption></figure><h3>JSON structure signature</h3><p>When you discovering a data, it’s useful to have a clue about its structure. Just hover a “𝕊” button in action bar on an expanded object or array and you’ll see structure signature of subtree like in TypeScript:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MshEJ4JUvs1m7U5yIo2vUA.png" /><figcaption>Data structure signature like in TypeScript, useful for a set of objects</figcaption></figure><p>You also can hover a property or a value in the structure signature popup to get some details, e.g. used values for a field:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QlW59rGtFTao4uE8g9k9tg.png" /><figcaption>Quick overview of used values in field</figcaption></figure><h3>JSON queries</h3><p>A click on “Make report” button moves you to a page where you can query to your JSON or/and customize its presentation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y7cjqD_02Ibf0dypmCSzTg.png" /><figcaption>“Make report” button unlocks data queries</figcaption></figure><p><a href="https://github.com/discoveryjs/jora">Jora</a> language is using for queries. Jora partially based on JavaScript’s 2015+ syntax, but has been created to be compact and express more (in term of a query).</p><p>Usually you only need to select a subset of data by using a path, e.g. foo.bar.baz. If a key contains prohibited characters just use [] (square brackets), e.g. foo[&#39;a key with whitespaces&#39;] . That’s all like in JavaScript, except no need to bother about path existence:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g6C_UxuYmqF9zMRUw7s0tw.png" /><figcaption>A simple path query</figcaption></figure><p>A common case is to use a filter or/and a map. Jora offers .[] for filtering and .() for mapping:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3avttfBBxl5Byqp2cenU_A.png" /><figcaption>A query with filter and map</figcaption></figure><p>Example on the screenshot above ( cards.[health].({ name, health })) can be written in JavaScript this way:</p><pre>cards.filter($ =&gt; $.health).map($ =&gt; ({ name: $.name, health: $.health }))</pre><p>That is too verbose, isn’t it?</p><p>You can find more about <a href="https://github.com/discoveryjs/jora">Jora</a> itself and its syntax on its <a href="https://github.com/discoveryjs/jora">repo</a> on github. (Btw, it also has a <a href="https://github.com/discoveryjs/jora-cli">CLI</a> and a <a href="https://discoveryjs.github.io/jora-sandbox/">sandbox</a>)</p><h3>Suggestions on a query</h3><p>This feature can’t be explained right. Just try it by yourself. At least once:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FVhHjpiN4GgY%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DVhHjpiN4GgY&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FVhHjpiN4GgY%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2c1c09a36cc7d4e8a543dee31f83de53/href">https://medium.com/media/2c1c09a36cc7d4e8a543dee31f83de53/href</a></iframe><h3>JSON data presentation</h3><p>When you select a desired data, you can customise its look. For example, output it as a table, or a list, something like that:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FgPn9tk_OhxA%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DgPn9tk_OhxA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FgPn9tk_OhxA%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/56767b70f69e4b30abda40458c193258/href">https://medium.com/media/56767b70f69e4b30abda40458c193258/href</a></iframe><p>Unfortunately, for now is lack of documentation about view description (all you can find currently, can be found on <a href="https://github.com/discoveryjs/discovery">discovery.js repo</a>). However, I believe it will be fixed in the nearby future.</p><h3>Sharing a report with a link</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F59vG38mZv9s%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D59vG38mZv9s&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F59vG38mZv9s%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/cfb604e9f16b9c068cc67f51edb93ed2/href">https://medium.com/media/cfb604e9f16b9c068cc67f51edb93ed2/href</a></iframe><p>That’s were most excited features in JsonDiscovery, but there are much more small features, because the extension and underling projects crafting with attention to details. And I can say for sure, it changes the way we’re viewing JSON.</p><p><a href="https://github.com/discoveryjs/browser-extension-json-discovery">JsonDiscovery</a> is available as extension for <a href="https://chrome.google.com/webstore/detail/jsondiscovery/pamhglogfolfbmlpnenhpeholpnlcclo">Chrome</a> and <a href="https://addons.mozilla.org/en-GB/firefox/addon/jsondiscovery/">Firefox</a>, and developing as open source project by <a href="https://github.com/exdis">Denis Kolesnikov</a>. It’s based on <a href="https://github.com/discoveryjs/discovery">Discovery.js</a> project, which is on early stage of development, but already useful for projects like JsonDiscovery. So, more improvements and new features are coming soon.</p><p><a href="https://twitter.com/js_discovery">Stay tuned</a>!</p><figure><a href="https://usejournal.com/?utm_source=medium.com&amp;utm_medium=noteworthy_blog&amp;utm_campaign=tech&amp;utm_content=guest_post_image"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PYxBP_WV7LI6zc-zdUkNqQ.png" /></a></figure><p>📝 Read this story later in <a href="https://usejournal.com/?utm_source=medium.com&amp;utm_medium=noteworthy_blog&amp;utm_campaign=tech&amp;utm_content=guest_post_read_later_text&amp;source=post_page---------------------------">Journal</a>.</p><p>👩‍💻 Wake up every Sunday morning to the week’s most noteworthy stories in Tech waiting in your inbox. <a href="https://usejournal.com/newsletter/noteworthy-in-tech/?utm_source=medium.com&amp;utm_medium=noteworthy_blog&amp;utm_campaign=tech&amp;utm_content=guest_post_text&amp;source=post_page---------------------------">Read the Noteworthy in Tech newsletter</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=51eda9103fa2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>