<?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 Joshua Reed on Medium]]></title>
        <description><![CDATA[Stories by Joshua Reed on Medium]]></description>
        <link>https://medium.com/@joshua_reed?source=rss-4f1cbc7d196d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*r12g6fcBQzYQ0RtXlVRyUw.png</url>
            <title>Stories by Joshua Reed on Medium</title>
            <link>https://medium.com/@joshua_reed?source=rss-4f1cbc7d196d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 12:36:31 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@joshua_reed/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[CharacterSheet: Building a flexible RPG character sheet]]></title>
            <link>https://medium.com/@joshua_reed/charactersheet-building-a-flexible-rpg-character-sheet-17de2febea08?source=rss-4f1cbc7d196d------2</link>
            <guid isPermaLink="false">https://medium.com/p/17de2febea08</guid>
            <dc:creator><![CDATA[Joshua Reed]]></dc:creator>
            <pubDate>Sat, 14 Nov 2026 01:04:20 GMT</pubDate>
            <atom:updated>2026-11-14T01:04:20.497Z</atom:updated>
            <content:encoded><![CDATA[<h3>The rules that keep it trustworthy during play.</h3><p>Personal project / Product &amp; engineering</p><p><strong>The engineering question:</strong> How do I let people change the sheet without losing control of the character?</p><p><strong>Ownership:</strong> Personal project / Creator<br><strong>Core stack:</strong> Next.js · React · TypeScript · PostgreSQL<br><strong>Focus:</strong> Flexible documents · Permissions · Persistence</p><h3>A sheet has to work at the table</h3><p>I created CharacterSheet to give RPG character information a useful home online. A character is more than a collection of numbers: it has abilities, equipment, notes, and rules about who can change what. During a game, those details need to be easy to find and safe to update.</p><p>The harder problem is flexibility. A fixed form is straightforward to build, but it makes every character fit the same structure. A configurable sheet gives people more control, then introduces different problems: layout, field bindings, permissions, and saved values all have to stay in agreement.</p><p>My goal is a sheet people can shape around their game without making ordinary play feel like editing a document template. That distinction drives the product and the engineering behind it.</p><h3>Connect the whole workflow</h3><p>CharacterSheet is my personal project. I work across the product interface, React components, TypeScript models, API boundaries, PostgreSQL persistence, and regression tests. The work connects small interaction decisions to the rules that protect the saved character.</p><p>I use the project to answer practical questions. What should a player be able to change during play? What belongs in the layout editor? How should a proposed change differ from an accepted value? Those questions are more useful than adding controls without a clear workflow.</p><h3>Design, use, and review are different jobs</h3><p>The sheet workflow separates arranging a sheet from filling it in. Design work deals with pages, blocks, fields, labels, and configuration. Normal use deals with the character’s values. A person should not need layout-editing powers just to update a permitted field.</p><p>Permissions add another path: suggesting a change. A proposed field value can be reviewed, accepted, rejected, or withdrawn instead of silently becoming the character’s current value. The interface has to make that distinction visible, and the server has to preserve it.</p><p>This also changes how I think about locks. A lock is part of a permission model, not just a disabled input. The experience needs to explain what someone can do while the mutation rules decide what can actually be saved.</p><h3>Separate structure from values</h3><p>The custom sheet model separates the definition from the values it displays. The definition describes the layout and fields; bindings connect those fields to known value paths. Permissions, suggestions, and sheet state are represented explicitly rather than inferred from whatever happens to be on screen.</p><p>That separation lets layout and character data evolve for different reasons. It also creates real maintenance work: older saved documents need to remain readable, changed definitions need their values reconciled, and unknown paths need to be rejected rather than quietly stored.</p><p>I use TypeScript models and validation around the document boundary. PostgreSQL stores the durable state, including JSON documents for the flexible parts of a sheet. Flexible storage is useful here, but it does not remove the need for a strict mutation contract.</p><h3>Make the server responsible for trust</h3><p>The application uses Next.js and React, with server routes between the interface and PostgreSQL. Authentication establishes who is making a request. Ownership, roles, field capabilities, and locks determine whether that request is allowed. Those are separate decisions.</p><p>The custom sheet mutation contract checks incoming changes against the persisted sheet and permitted paths. Hiding an editor control is useful interface feedback; it is not enough to protect a saved record. A request still needs to be checked when it reaches the server.</p><p>I keep that boundary distinct from feature availability. Campaign and owner tools have their own gates, and a feature flag does not grant permission to someone’s character. This keeps a broader platform from turning into one shared set of loosely connected access checks.</p><h3>The difficult parts sit between features</h3><p>One challenge is keeping the rendered sheet and its editor consistent. The product rule is that viewing and editing should describe the same sheet; the difference is capability. Shared layout rules matter because even a small disagreement in sizing or field placement can make switching modes confusing.</p><p>Another is persistence across multiple kinds of change. Editing a value, changing a definition, and accepting a suggestion are not interchangeable operations. Tests need to check what survives a save and reload, not only what appears immediately after a click.</p><p>Compatibility is part of that work. The underlying definition still has a section/block structure while the interface uses a Page → Block → Field model. I treat that as an existing constraint to handle carefully, rather than assuming a clean rewrite is the answer.</p><h3>Test the rules, then test the experience</h3><p>The regression strategy has several layers. Mutation-contract tests exercise permitted edits, rejected paths, role restrictions, locked fields, and suggestion behavior. Persistence tests cover loading and saving sheet state. Component and browser tests cover the interactions that connect those rules to the interface.</p><p>The repository also separates browser-test data from live PostgreSQL access. Its end-to-end mode uses a test adapter that blocks direct database access, with mocked routes or explicitly safe test storage for the scenarios under test. A passing browser run should never depend on changing a real person’s character.</p><p>I do not treat a green test run as the whole product review. Layout consistency, readable feedback, and the feel of using a sheet still need visual and manual checks. The tests give me a way to revisit a difficult edge case without relying on memory.</p><h3>What exists, and what I am still learning</h3><p>The codebase includes a character workspace, configurable sheet rendering and editing, persisted custom sheet documents, and explicit permission and suggestion rules. That is a much richer engineering problem than the original idea of putting character information online.</p><p>This is an evolving personal project, not a claim of broad public adoption. Campaign workflows and owner tools include gated functionality. This case study describes verified implementation; it does not present every implemented feature as publicly available, or work in progress as a released result.</p><p>The main lesson for me is that flexibility needs boundaries. A clear model for structure, values, and authority makes the interface easier to reason about. The next measure of quality is how reliably those pieces work together during ordinary play, including the less exciting moments: a reload, a rejected change, or a return to a saved character.</p><p>Want to talk through the model, the tradeoffs, or the testing approach? I am happy to walk through the work. A public product demo is not linked here.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17de2febea08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What If Your Character Sheet Felt Like Your Character?]]></title>
            <link>https://medium.com/@joshua_reed/what-if-your-character-sheet-felt-like-your-character-006c6e18309b?source=rss-4f1cbc7d196d------2</link>
            <guid isPermaLink="false">https://medium.com/p/006c6e18309b</guid>
            <category><![CDATA[ttrpgs]]></category>
            <category><![CDATA[dungeons-and-dragons]]></category>
            <category><![CDATA[character-sheet]]></category>
            <dc:creator><![CDATA[Joshua Reed]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 18:30:59 GMT</pubDate>
            <atom:updated>2026-10-28T19:39:09.929Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YQoRY-3EZCsXTLYF9yCsaQ.png" /></figure><p>Every character starts with an idea.</p><p>Maybe yours is a cleric who carries the names of people he could not save. Maybe it is a rogue who keeps track of every promise she makes, even the ones she never intended to keep.</p><p>Those details might matter just as much to the story as armor class or hit points. They shape how your character sees the world and what they might do when the party faces a difficult choice.</p><p>But where do you keep them?</p><p>Some details end up in a notebook. Others get buried in a message thread or mentioned once at the table and forgotten a few sessions later. I have had moments where I knew there was something important about my character or the campaign, but I could not remember where I wrote it down.</p><p>That has me thinking about what a character sheet could be.</p><p>More Room for the Story</p><p>Imagine opening your character sheet before a session and seeing more than your abilities and equipment.</p><p>You could see the name of an NPC your character promised to protect. You might have a note about the strange symbol your party found in a ruined temple. Maybe there is a section for the magic item your game master created just for your campaign.</p><p>Those details could be close by when you need them, alongside the rules you use throughout the game.</p><p>Every group plays differently. One campaign might focus on political alliances and family history. Another might be about exploring dangerous ruins and keeping track of the unusual things the party discovers. A sheet that fits one character or campaign might look very different from another.</p><p>I like the idea of giving players and game masters the freedom to make a sheet that reflects the game they are playing.</p><p>A Place for Your Table’s Ideas</p><p>One of my favorite parts of tabletop roleplaying is seeing what people create together.</p><p>A player comes up with a backstory detail. The game master connects it to something happening in the world. Another player asks a question that takes the story in a direction nobody expected.</p><p>Those moments are why I want CharacterSheet to support more than a standard set of boxes. I want it to give groups room to organize the things that make their characters and campaigns unique.</p><p>I am still building toward that vision. There is a lot to consider, and I want to hear how other people play and what they would find useful.</p><p>For me, a good character sheet should help me remember who my character is and give me an easy way to find what I need while we are playing.</p><p>What about you? What is one detail about your character or campaign that you wish was easier to keep close during a session?</p><p>I’m building CharacterSheet with this vision in mind. If you’re interested in seeing the application, visit <a href="http://charactersheet.app/">CharacterSheets.app</a>. I would love to hear what you think and what you would like to see as it grows.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=006c6e18309b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Crafting Effective Jest Tests for Next.js with React Testing Library and MUI Components]]></title>
            <link>https://medium.com/@joshua_reed/crafting-effective-jest-tests-for-next-js-with-react-testing-library-and-mui-components-cb2419caf190?source=rss-4f1cbc7d196d------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb2419caf190</guid>
            <category><![CDATA[mui]]></category>
            <category><![CDATA[react-testing-library]]></category>
            <category><![CDATA[jest]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Joshua Reed]]></dc:creator>
            <pubDate>Fri, 08 Mar 2024 21:49:59 GMT</pubDate>
            <atom:updated>2024-03-08T21:49:59.621Z</atom:updated>
            <content:encoded><![CDATA[<p>Testing stands as a cornerstone in software development, ensuring the seamless operation and reliability of our applications. In the realm of React applications crafted with Next.js and integrating Material-UI (MUI) components, writing meticulous tests holds paramount importance. This article embarks on a journey to explore the art of composing Jest tests utilizing React Testing Library for a Next.js application enriched with MUI components. We’ll specifically focus on scrutinizing component states and crafting tests for a contact form.</p><h3>Preparing the Environment</h3><p>Prior to delving into the intricacies of test writing, let’s ensure our development environment is meticulously set up. Make certain to have the following dependencies at your disposal:</p><ol><li>Node.js and npm (or yarn) for seamless package management.</li><li>Next.js, serving as the foundation for constructing React applications.</li><li>React Testing Library, empowering us to test React components effortlessly.</li><li>Jest, the trusted companion for executing tests seamlessly.</li><li>Material-UI, offering an array of MUI components to enrich your application.</li></ol><p>Once these dependencies are gracefully installed, you’re poised to embark on the journey of crafting tests for your Next.js application.</p><h3>Crafting Jest Tests</h3><h4>Delving into Component State Examination</h4><p>Scrutinizing the state of components is a pivotal aspect ensuring our application behaves impeccably under varied circumstances. Let’s fashion a simple React component housing a state and craft a test to scrutinize its behavior:</p><pre>// components/Counter.js<br>import React, { useState } from &#39;react&#39;;<br><br>const Counter = () =&gt; {<br>  const [count, setCount] = useState(0);<br><br>  const increment = () =&gt; setCount(count + 1);<br><br>  return (<br>    &lt;div&gt;<br>      &lt;p&gt;Count: {count}&lt;/p&gt;<br>      &lt;button onClick={increment}&gt;Increment&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>};<br><br>export default Counter;</pre><p>Subsequently, let’s mold a Jest test for this component:</p><pre>// components/__tests__/Counter.test.js<br>import { render, fireEvent } from &#39;@testing-library/react&#39;;<br>import Counter from &#39;../Counter&#39;;<br><br>test(&#39;increments the count when the button is clicked&#39;, () =&gt; {<br>  const { getByText } = render(&lt;Counter /&gt;);<br>  const incrementButton = getByText(&#39;Increment&#39;);<br><br>  fireEvent.click(incrementButton);<br><br>  expect(getByText(&#39;Count: 1&#39;)).toBeInTheDocument();<br>});</pre><p>This meticulous test verifies whether the count increments upon button click.</p><h4>Delving into Contact Form Testing</h4><p>Forms serve as quintessential components in web applications, warranting rigorous testing to ensure their flawless functionality. Let’s concoct a simplistic contact form employing MUI components and sculpt tests to validate its behavior:</p><pre>// components/ContactForm.js<br>import React, { useState } from &#39;react&#39;;<br>import { TextField, Button } from &#39;@mui/material&#39;;<br><br>const ContactForm = () =&gt; {<br>  const [name, setName] = useState(&#39;&#39;);<br>  const [email, setEmail] = useState(&#39;&#39;);<br><br>  const handleNameChange = (e) =&gt; setName(e.target.value);<br>  const handleEmailChange = (e) =&gt; setEmail(e.target.value);<br><br>  const handleSubmit = (e) =&gt; {<br>    e.preventDefault();<br>    // Handle form submission logic<br>  };<br><br>  return (<br>    &lt;form onSubmit={handleSubmit}&gt;<br>      &lt;TextField<br>        label=&quot;Name&quot;<br>        value={name}<br>        onChange={handleNameChange}<br>        variant=&quot;outlined&quot;<br>      /&gt;<br>      &lt;TextField<br>        label=&quot;Email&quot;<br>        value={email}<br>        onChange={handleEmailChange}<br>        variant=&quot;outlined&quot;<br>      /&gt;<br>      &lt;Button type=&quot;submit&quot; variant=&quot;contained&quot; color=&quot;primary&quot;&gt;<br>        Submit<br>      &lt;/Button&gt;<br>    &lt;/form&gt;<br>  );<br>};<br><br>export default ContactForm;</pre><p>Subsequently, let’s sculpt a Jest test for this contact form:</p><pre>// components/__tests__/ContactForm.test.js<br>import { render, fireEvent } from &#39;@testing-library/react&#39;;<br>import ContactForm from &#39;../ContactForm&#39;;<br><br>test(&#39;submits the form with user input&#39;, () =&gt; {<br>  const { getByLabelText, getByText } = render(&lt;ContactForm /&gt;);<br>  const nameInput = getByLabelText(&#39;Name&#39;);<br>  const emailInput = getByLabelText(&#39;Email&#39;);<br>  const submitButton = getByText(&#39;Submit&#39;);<br><br>  fireEvent.change(nameInput, { target: { value: &#39;John Doe&#39; } });<br>  fireEvent.change(emailInput, { target: { value: &#39;john@example.com&#39; } });<br>  fireEvent.click(submitButton);<br><br>  expect(nameInput).toHaveValue(&#39;John Doe&#39;);<br>  expect(emailInput).toHaveValue(&#39;john@example.com&#39;);<br>});</pre><p>This meticulous test ensures the form submits with precise user input.</p><h3>Wrapping Up</h3><p>Crafting Jest tests for Next.js applications adorned with React Testing Library and MUI components holds pivotal significance in maintaining code integrity and reliability. By meticulously following the paradigms outlined in this article, you can adeptly scrutinize component states and validate the functionality of intricate components such as forms. Intertwining testing into your development workflow serves as a cornerstone for sculpting robust and reliable applications in the long haul. Happy testing!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb2419caf190" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unit Testing Best Practices]]></title>
            <link>https://medium.com/@joshua_reed/unit-testing-best-practices-9c02c4eb4058?source=rss-4f1cbc7d196d------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c02c4eb4058</guid>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[integration-testing]]></category>
            <dc:creator><![CDATA[Joshua Reed]]></dc:creator>
            <pubDate>Fri, 08 Mar 2024 21:29:34 GMT</pubDate>
            <atom:updated>2024-03-08T21:29:34.453Z</atom:updated>
            <content:encoded><![CDATA[<p>1. Definition of a “Unit of Code”</p><ul><li>A function is considered a unit of code if it:</li><li>Contains business logic.</li><li>Is exported.</li><li>Is imported and called in another non-test file.</li></ul><p>2. Test Coverage for a Unit</p><ul><li>Cover the happy path, failure paths, and edge cases.</li><li>Consider omitted and empty data, as well as errors from external resources.</li><li>Mock anything outside the unit being tested, including external resources and imported functions.</li><li>Use realistic test data.</li><li>If mocking global functions like fetch becomes necessary, consider code reorganization for dependency injection.</li></ul><p>3. Rules of Thumb</p><ul><li>Good tests complement simple, clean, and readable code.</li><li>Tests serve as documentation but should not replace written documentation.</li></ul><h3>Integration Testing Best Practices</h3><p>1. Scope of Integration Tests</p><ul><li>Focus on testing plumbing code that calls functions covered by unit tests.</li><li>Each set of integration tests should cover distinct behaviors such as uploading a document or adding/removing notifications.</li></ul><p>2. Test Coverage for Integration</p><ul><li>Cover happy path, failure paths, and edge cases.</li><li>Consider errors, invalid data, repeated or out-of-order calls.</li><li>Use minimal mocking, reserving it for situations like per-use charges or security concerns.</li><li>Where applicable, verify the desired result actually occurred, such as entry creation in a DB or receipt of a notification email.</li><li>Use realistic test data.</li></ul><p>3. Rules of Thumb</p><ul><li>Like unit tests, good integration tests complement simple, clean, and readable code.</li><li>Tests provide documentation but should not replace written documentation.</li></ul><p>In both unit and integration testing:</p><ul><li>Strive for code reorganization if extensive mocking becomes necessary.</li><li>Remember that if struggling with mock implementation, it often indicates a need for code reorganization.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c02c4eb4058" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Art of Programming: Choosing and Mastering the Perfect Text Editor]]></title>
            <link>https://medium.com/@joshua_reed/the-art-of-programming-choosing-and-mastering-the-perfect-text-editor-c9a03c329ef?source=rss-4f1cbc7d196d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9a03c329ef</guid>
            <dc:creator><![CDATA[Joshua Reed]]></dc:creator>
            <pubDate>Fri, 28 Jul 2023 01:47:21 GMT</pubDate>
            <atom:updated>2023-08-28T15:14:01.539Z</atom:updated>
            <content:encoded><![CDATA[<p>In the world of computer programming, a text editor serves as an essential tool for developers, much like a specific brand of brushes for a painter. Just as painters carefully choose their colors and canvases to create masterpieces, programmers must select the most suitable text editor to write their code. This article delves into the significance of text editors for programmers, explores the history and types of text editors, and focuses on one remarkable text editor — Vim. Join us on this journey through the world of programming, where creativity and efficiency converge to craft elegant and robust software.</p><h3>The Evolution of Text Editors:</h3><p>The history of text editors traces back to the era of punch cards, but it wasn’t until 1967 that the first screen-based text editors emerged with the advent of computer terminals. Since then, the landscape of text editors has evolved significantly, offering programmers a wide array of options to choose from.</p><h3>Types of Text Editors:</h3><p>Text editors come in two primary types: WYSIWYG (What You See Is What You Get) and WYGIWYM (What You Get Is What You Mean). While WYSIWYG editors display the document exactly as it will appear, WYGIWYM editors focus on user commands to manipulate the text. Both types serve different purposes and cater to various programming needs.</p><h3>The Role of Text Editors in Programming:</h3><p>A text editor’s capabilities are astonishing; it empowers programmers to write code, and scripts, or even compose entire books with precision and finesse. Whether a programmer is typing code on a keyboard or an artist wields a brush on canvas, the chosen medium is vital in defining the output.</p><h3>Enter Vim: The Art of Efficiency and Creativity:</h3><p>Among the plethora of text editors available, Vim (Vi Improved) stands out as a remarkable choice for programmers. Despite its steep learning curve, Vim’s unique mode-based approach keeps users’ hands on the keyboard, minimizing reliance on a mouse and enhancing productivity. The philosophy of “Don’t Repeat Yourself” (DRY KISS) perfectly aligns with Vim’s design, allowing users to combine commands efficiently and achieve remarkable time savings.</p><h3>Mastering Vim:</h3><p>Vim’s learning process involves mastering an array of commands, such as h-j-k-l for cursor movement and using the w, e, and b keys to navigate through words. With a focus on mnemonic keystrokes, users can remember and execute commands seamlessly. Vim’s three modes — Normal mode, Insert mode, and Visual mode — offer flexibility in creating, editing, and manipulating text.</p><h3>Customization and Plugins:</h3><p>Vim’s true potential lies in its high level of customization. Users can modify key mappings, add plugins, and create personalized .vimrc files to enhance the editor’s functionality. With over 800 plugins available, Vim can be tailored to the user’s specific needs, making it a limitless and efficient tool for programmers.</p><h3>Distraction-Free Coding:</h3><p>Unlike other text editors, Vim prides itself on its simplicity and lack of flashy distractions. By keeping the focus solely on the text, Vim allows programmers to maintain their concentration and flow, resulting in a more immersive coding experience.</p><h3>Conclusion:</h3><p>The text editor is a fundamental tool for any computer programmer, shaping the way code is written, edited, and maintained. Vim, with its emphasis on efficiency and creativity, stands as an exemplar in the world of text editors. As programmers seek the perfect editor to accompany them on their coding journey, Vim remains a compelling choice, enabling them to unleash their artistic potential and create masterful programs with unmatched productivity. So, whether you’re a seasoned developer or just starting on your coding adventure, consider exploring the world of Vim and unlock new levels of efficiency and creativity in your programming endeavors.</p><p>Thank you for reading.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9a03c329ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is a Text Editor]]></title>
            <link>https://medium.com/@joshua_reed/the-text-editor-db0ee687ad82?source=rss-4f1cbc7d196d------2</link>
            <guid isPermaLink="false">https://medium.com/p/db0ee687ad82</guid>
            <dc:creator><![CDATA[Joshua Reed]]></dc:creator>
            <pubDate>Wed, 06 Oct 2021 18:56:03 GMT</pubDate>
            <atom:updated>2021-12-23T19:33:48.816Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D6bzL8CUQ4SXlLyP" /></figure><p>A text editor for a computer programmer is like a specific brand of brushes for a painter. The computer language to a computer programmer is like the colors a painter would paint with, and the computer of a programmer is comparable to the canvas of an artist. Just as there are all kinds of paintbrush brands that a painter could choose from to paint his picture. Similarly, there are a lot of text editors a computer programmer could want to utilize. The choice will matter to the painter, his preference, painting style, and the amount of money he would like to invest. A computer programmer has the same process to choose the text editor that he/she would want to program with. Both painter and computer programmer will go through many different brands during the learning process and will eventually decide on which they prefer.</p><p>Text editors are in use both as word processing and programming platforms. The main difference between these two platforms is that text editors are meant to have plain text (e.g., ASCII, UTF-8) editors and do not usually insert special characters aiding in formatting or with binary instructions. (Fabbri, 2017) There are two different types of text editors: WYSIWYG, “what you see is what you get,” meaning what happens on the screen is what the user input. WYGIWYM “what you get is what you mean” The user inputs a command to move around the curser, then when ready inserts text into the document. (Fnaukk &amp; Jasmince, 2014) What a text editor can do is impressive! Under the direction of the user, you could write a book, poem, or sophisticated computer program. Whether it be by user keystrokes on the keyboard or a paintbrush on a canvas, using the language or color of the artist’s choice, the computer programmer or painter will create art on the canvas of his/her choosing.</p><p>The history of the text editor began with punch cards. The holes punched into the card were an organized list of commands that the computer would execute. When the first computer terminals with screen displays were designed, they needed to create a way to type on the screen. Thus, creating the first screen-based text editors in 1967. (Text editor, 2018) In 1970 Bram Moolenaar, creator of Unix created Vi (pronounced Vee Eye) one of the first full-screen text editors. The primary focus of the text editor in the hands of a computer programmer is to have the ability to modify the text so that the user, a computer programmer, will enjoy the experience and utilize it on a more consistent basis.</p><p>The creators of these text editors made money to do so in times past. Now there are so many available to use that they are generally free to all with merely a request for donations. Many programmers are happy to donate to those who create the best and most useful text editors because it allows the creators to continue building even more and better text editors and other programs used by programmers. Professional programmers spend eight-plus hours in a text editor designing and creating programs. Knowing this information, it is obvious that a well-thought-out and smoothly executing text editor is essential to a programmer. In retrospect, we can imagine all of the great business empires, hospitals, and even your everyday users such as college students and professors that need the programs created by programmers that use text editors to create such programs as Word, Excel, PowerPoint, and hundreds of others.</p><p>The general public is entirely oblivious to the notion of their lives are being touched numerous times each day by programs constantly running in various forms of technology, keeping our lives running at an impressive pace. They are only able to do so because somewhere at some point in time a programmer had a vision and decided to make it happen, which he/she could only do using a text editor. It is also essential to the everyday user because without a text editor some of the options that are standard for most text editors are things such as simple syntax highlighting for keywords in a given language, automatic indention, text indenting, and aligning code/text for the user to be organized, spell check, which checks the spelling of our term papers, business proposals, or instructions given to perform lifesaving procedures with the technology given to us.</p><p>Sometimes programmers have a difficult time deciding which text editor they want to work with. Most programmers will use many different editors before deciding on just one favorite. That decision is varying at times because the development of technology and personal preference changes often. Some examples of the 61 different text editors out there are Vim, Visual Studio Code, Sublime Text, and Notepad++. I think the best text editor for computer programmers is Vim, even though it has a steep learning curve, it keeps the user’s hands on the keyboard and is a highly customizable program without a flashy UI (user interface or what the user sees on the screen) and holds to the profound ideology of do not repeat yourself.</p><p>Vim stands for Vi Improved, the name Vim initially started with was Vi derivative, from visual, as one of the first text editors to have the option to copy and paste the text. It is different from most text editors in the way the user commands the cursor in the document. Steven Melendez says, “If you want to improve productivity on any piece of frequently used software there’s a simple solution: ditch the mouse and use keyboard shortcuts instead.” Vim uses a different approach than all other text editors called WYGIWYM which utilizes a different thought process; you must first pattern out what you are going to do by using the thousands of key combinations available to simply move a cursor around long before any editing is accomplished. It’s not as simple as point and clicks or up and down arrows. For example, if you currently are on line five of a document and need to move down ten lines, you would type 10j for up ten lines or 10k for down ten lines. Using this simple but efficient command as explained in this example cuts out seven keystrokes of tapping the down or up arrow keys to only three keystrokes. This “jumping lines” example can be applied to any amount of lines needed or seemingly endless other command possibilities, resulting in an almost endless number of keystrokes and ridiculous amounts of time saved. Renato Fabbri a Computer Science student at Sao Carlos, SP, Brazil shares a great acronym of “DRY KISS” (Don’t Repeat Yourself, Keep it Simple Stupid). (Fabbri, 2017) Dry kiss is a perfect acronym and ideology running in perfect sync with Vim as you can combine multiple commands to accomplish so many things and the program works to keep the user from repeating oneself and simplifying processes. (Ottinger, 2014)</p><p>Mnemonics, helps you remember keystrokes that are associated with commands built into Vim, it is the key component to all of the major functional commands of Vim. If you wish to delete a word, you will use the key command dw (delete word). Vim is a multi-mode text editor; there are three modes Vim uses: Normal mode, Insert Mode, and Visual Mode. Each mode has different commands used within the program. I have heard of Vim causing first-time users to cry due to the intricate complexity of the program. The creators of Vim wanted the user to abandon the mouse completely and focus on only using the keyboard. Normal mode alone has thousands of key commands to move the cursor around the screen to edit the text. For the sake of time and paper I won’t get into the variances of the other two modes, just know that there are volumes of books written on the subject. I prefer Vim to others because of how the cursor “walks” around the text combined and I enjoy how customizable the program can become as it becomes easier to use with time. Vim is considered by its creators to be the top text editor for anyone editing text because it keeps the user’s fingers on the keyboard home row instead of constantly flailing all over the place as some keyboard-focused programs will do.</p><p>Vim’s unique process to move the cursor around the screen by using the lower-case h-j-k-l keys will move your cursor around the sentences the cursor is currently positioned. H moves the cursor to the left, J moves the cursor down one line. K moves the cursor up one line, and l moves the cursor to the left. Using the h-j-k-l will help move around the multiple lines while replacing the arrow keys and will help the user eliminate hand movement which increases productivity. There is a learning process to Vim, unlike any other text editor. Once the user has mastered the h-j-k-l keys, the user should stop using them as much and start using larger cursor movement keys. w key will move to the beginning of the next word in the line. e will move the cursor to the end of the next word in the line, and b will move the cursor to the beginning of the previous word. Insert mode is very straightforward and easy to understand. When the user enters, insert mode by hitting the I key while in normal mode. The user will be able to start typing on the screen until the user hits &lt;Esc&gt;. Hitting &lt;Esc&gt; will take the user out of insert mode and back to a normal mode allowing the user to move the cursor to another part of the screen. Visual mode is for yank (y key), a computer term for copy, and paste (p key). There are also ways to copy or delete whole lines of text and move them to another place on the screen by hitting d twice. The user would then move the cursor to another part of the screen to paste the line.</p><p>Vim is very customizable in its setup to accomplish just about any task however it’s the user&#39;s responsibility to become more efficient in using fewer keystrokes as they learn. Out of the box,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D6bzL8CUQ4SXlLyP" /></figure><p>Vim is very plain as shown here. The only visual increase that can be shown is the status bar available at the bottom of the screen. It can show more information the user might want to have available in the future. These options can be the filename, line number, percentage of where the cursor is regarding the length of the file (basically known as a location), current line length, size of the file, and so much more. The formatting can also be changed to include colors and different styles of text. The more customizable area of Vim is the .vimrc file is a file in which the user runs lines of script and Vim looks at to assist in better utilization. This file includes which plugins are active, how the user would like to see syntax and color, and line numbers on the screen. The user can also change any to all of the key mappings for their Vim program. There is also an auto-fill function if the user has a certain word or group of syntax he/she would like to combine with series of other letters or phrases and can print out exactly what is seen on the screen. For example, whenever the user wants to insert a complete commented paragraph the user could type ;**.</p><p>/*****************************************************************************<br>* Function: Example</p><p>* Use: Example use</p><p>*****************************************************************************/</p><p>From 3 keystrokes this commented layout would appear on the screen for the user to utilize for his/her program. As opposed to however many pecks that would have taken others to type out manually. Yet another example of the sweet efficiency and necessity of a text editor. Anything can be created with or formatted by using this ability because it is determined by the users’ creativity and knowledge of the program&#39;s possibilities.</p><p>The user can create plugins or installed them from the vast Vim community. Currently, there are over 800 plugins that have a vast variety of different tasks and styles. The various plugins can include file managers, customizable syntax color schemes, different language syntax, and much more. The major takeaway is that Vim is virtually unlimited to just about anything that the user can imagine increasing their user performance.</p><p>Vim by design helps keep the focus on the text and away from extra “flashy” options that other text editors have. These flashy options can get in the way and are drop-down menus that grab the user’s attention. Also included are buttons at the top, side, or bottom of the program window. While the user is typing auto-complete drop-down lists are not flashing in front of them or disrupting the train of thought. Most programmers have a bad habit of fidgeting with configuration settings. When these settings sit at the top of your window continually, it draws your attention to modify them over and over if something is stating that it is not correct. Or if you are editing a different setting, there are so many that flash in front of your face at any given time that programmers often confuse what they are changing. For example, in almost all other programs there is a settings window that shows all different settings that can be modified. Which can be fun for the programmer to change but can take away from the experience of the art the user is essentially trying to achieve.</p><p>Vim is a mode-style text editor vs. non-mode text editor. Modes mean that when you open Vim compared to the other editors, you cannot start typing and words show on the screen. Normal mode is the default mode for Vim. Just as quickly as the curser can get to certain parts of the text, the user can also edit the document. Vim, Visual Studio Code, Sublime, and Notepad++ all start and stay in insert mode. In insert mode, the user can start immediately typing, and characters will start to show up on the screen. This is unique only in the sense that while in other modes and in other programs you can be typing, and the characters do not immediately show on the screen. These are commands that you are typing and while these programs and this mode shows what you have typed others will not and nothing will happen until you have executed the correct key combinations and the only way you can tell if you have done that is if what you intended to happen does in fact happen. The issue comes when the user wants to change something in their document a few lines or even a few characters back. The user must use the mouse or the arrow keys to adjust the cursor to where the correction needs to be made. That moment from the keyboard to the mouse seems insignificant, or to hit the arrow key a few times to get the cursor into position to make the needed edit seems insignificant. In this area, Vim shows extreme proficiency and displays how the built-in modes shine. There is an array of movements in the line to move to the spot you need.</p><p>There is a steep learning curve to Vim that the other text editors do not have as far as the up-and-running process takes. Once any of the other editors are in place, you can start to type into that given text editor. Quick access might seem significant to start a project fast and get the preliminary work done. But as editing and launching the programs you build you will have to depend on the mouse and very few available other shortcuts to move around your document efficiently. Unfortunately, no official documentation shows how much time or saved keystrokes someone gains vs. any other text editor. There are too many factors to take into consideration. After using Vim personally for many projects, I can attest to the excellent qualities and intricate balance that this wonderful text editor provides when creating a programmer work of art, his/her epic program.</p><p>References</p><p>Dr. Harvey, E., Philpott, A., Hoffmaster, A., &amp; Grodi, D. (2018). Md simulations at fsu. Retrieved from <a href="https://sites.google.com/site/mdsimulationsatfsu/home">https://sites.google.com/site/mdsimulationsatfsu/home</a></p><p>Fabbri, R. (2017). An anthropological account of the Vim test editor: features and tweaks after 10 years of usage. University of S˜ao Paulo, Institute of Mathematical and Computer Sciences, S˜ao Carlos, SP, Brazil. Retrieved 3 2018, from <a href="https://arxiv.org/pdf/1712.06933.pdf">https://arxiv.org/pdf/1712.06933.pdf</a></p><p>Fnaukk, K., &amp; Jasmince, J. (2014, December 19). An efficiency comparison of text editors used in academic research and development. PLoS ONE, 9(12). doi:10.1371/journal.ptwo.0115069</p><p>Mulholland, M. (1991, June). More than you ever wanted to know about code editors. 75+. Retrieved from <a href="http://link.galegroup.com.byui.idm.oclc.org/apps/doc/A10881314/CDB?u=byuidaho&amp;sid=CDB&amp;xid=c9e9c0f7">http://link.galegroup.com.byui.idm.oclc.org/apps/doc/A10881314/CDB?u=byuidaho&amp;sid=CDB&amp;xid=c9e9c0f7</a></p><p>Neil, D. (2012). Practical Vim : edit text at the speed of thought. (K. Keppler, Ed.) Dallas, Texas: The Pragmatic Bookshelf, [2012]. Retrieved 3 2018</p><p>Shotts, Jr, W. E. (2012). The Linux Command Line. William Pollock. Retrieved 3 2018</p><p>Sufrin, B. (1982). Formal specification of a display-oriented text editor. In M. Sintzoff, Science of Computer Programming (Vol. 1, pp. 157–202). Oxford, OX2 6PE, nited Kingdom: North-Holland Publishing Company. doi:https://doi.org/10.1016/0167-6423(82)90014-4</p><p>Sublime Text 3</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/0*0GbKqA9ZR4PKT8kE" /></figure><p>Figure 2 open screen of Sublime Text 3</p><p>Visual Studio Code</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*daFwdVOhsYIeT_Di" /></figure><p>Figure 3</p><p>Notepad++</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yhiXIdCGde4XwQp4" /></figure><p>Figure 4 Open screen of Notepad++</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db0ee687ad82" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>