# readability

Published articles for readability.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## CAA DNS Issuer-Critical Flags Are Confusing to Configure

DevFeed: [CAA DNS Issuer-Critical Flags Are Confusing to Configure](<https://devfeed.tech/articles/a-bit-of-dns-28502.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/a-bit-of-dns>)

Author: Remy Porter

Published: 2026-09-10T06:30:00Z

Content type: opinion

Language: en

Sources: [The Daily WTF](<https://devfeed.tech/sources/the-daily-wtf.md>)

Topics: [certificates](<https://devfeed.tech/topics/certificates.md>), [domain](<https://devfeed.tech/topics/domain.md>)

Tags: [bits](<https://devfeed.tech/tags/bits.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [certificates](<https://devfeed.tech/tags/certificates.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [feature-articles](<https://devfeed.tech/tags/feature-articles.md>), [flag](<https://devfeed.tech/tags/flag.md>), [https](<https://devfeed.tech/tags/https.md>), [readability](<https://devfeed.tech/tags/readability.md>)

### AI overview

The article examines confusion around the issuer-critical flag in DNS CAA records. It explains that the flag is defined as a bitmask, while many users interpret the documentation as requiring the integer 1 instead of the value representing the specified bit, creating a dilemma for certificate issuers such as LetsEncrypt.

### Source excerpt

I'm not a DNS person, in that I appreciate that it exists but am not up on the inner workings. It solves a lot of problems with dark magic I don't fully understand, and fortunately don't need to. But Lucio noticed something that I do think is interesting, within the scope of the CAA record type. The CAA record started with RFC6844, which was obsoleted by RFC8659. Both RFCs lay out the same core idea: you can add a CAA record to your DNS entries to say, "hey, this domain over here is allowed to issue certificates for me". That's the sort of thing that enables LetsEncrypt to hand out certs, and is an important part of why we can run HTTPS everywhere these days. Now, RFC6844 has this in it: Issuer Critical: If set to '1', indicates that the corresponding property tag MUST be understood if the semantics of the CAA record are to be correctly interpreted by an issuer. Issuers MUST NOT issue certificates for a domain if the relevant CAA Resource Record set contains unknown property tags that have the Critical bit set. The issuer critical flag means that the certificate issuer needs to validate your CAA record before it issues a certificate for you. There's more in the RFC about what exactly that means, but we don't care about those details for right now. The rule here is "set a flag to 1". A little later in the RFC, the flag is described in more detail- as a bitmask. Specifically, bit 0 is the issuer critical flag. Bits 1-7 are reserved for future use. Now, here's where we get into trouble, because programmers don't understand bits, and because the CAA record expects you to put an integer in this field. So, if you want issuer critical enabled, what value to you put in this field? 128, obviously. That's 10000000. Except, if you don't understand bits, that's not obvious. A lot of people read this and decided that the documentation meant they needed to put 1 in the field- aka 00000001. This is wrong. The updated RFC tries to explain it a bit more clearly: Bit 0, Issuer Critic

## 25+ Free Minimal Fonts for Modern Design

DevFeed: [25+ Free Minimal Fonts for Modern Design](<https://devfeed.tech/articles/25-free-minimal-fonts-for-modern-design-9288.md>)

Original publisher: [Read original article](<https://speckyboy.com/free-minimal-fonts/>)

Author: Paul Andrew

Published: 2026-08-25T15:22:37Z

Content type: article

Language: en

Sources: [Speckyboy Design Magazine](<https://devfeed.tech/sources/speckyboy-design-magazine.md>)

Topics: [Font](<https://devfeed.tech/topics/font.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [branding](<https://devfeed.tech/tags/branding.md>), [design](<https://devfeed.tech/tags/design.md>), [display-fonts](<https://devfeed.tech/tags/display-fonts.md>), [fonts](<https://devfeed.tech/tags/fonts.md>), [geometric-fonts](<https://devfeed.tech/tags/geometric-fonts.md>), [legibility](<https://devfeed.tech/tags/legibility.md>), [logo-design](<https://devfeed.tech/tags/logo-design.md>), [minimal-design](<https://devfeed.tech/tags/minimal-design.md>), [monospace-fonts](<https://devfeed.tech/tags/monospace-fonts.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [post](<https://devfeed.tech/tags/post.md>), [readability](<https://devfeed.tech/tags/readability.md>), [sans-serif-fonts](<https://devfeed.tech/tags/sans-serif-fonts.md>), [serif-fonts](<https://devfeed.tech/tags/serif-fonts.md>), [typography-design](<https://devfeed.tech/tags/typography-design.md>), [ui](<https://devfeed.tech/tags/ui.md>), [web-fonts](<https://devfeed.tech/tags/web-fonts.md>)

### AI overview

A curated collection of free minimalist fonts for modern design, covering typefaces suited to branding, logos, posters, print, digital projects, and readable small text.

### Source excerpt

A curated collection of the best free fonts for minimalist design. Check out the full round-up and add them to your design library. The post 25+ Free Minimal Fonts for Modern Design appeared first on Speckyboy Design Magazine.

## Which Doc Format is Best for AI Specifications?

DevFeed: [Which Doc Format is Best for AI Specifications?](<https://devfeed.tech/articles/which-doc-format-is-best-for-ai-specifications-30762.md>)

Original publisher: [Read original article](<http://blog.vanillajava.blog/2026/07/which-doc-format-is-best-for-ai.html>)

Author: Peter Lawrey (noreply@blogger.com)

Published: 2026-07-14T14:00:28Z

Content type: article

Language: en

Sources: [Vanilla Java](<https://devfeed.tech/sources/vanilla-java.md>)

Topics: [Specifications](<https://devfeed.tech/topics/specifications.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>), [Fable](<https://devfeed.tech/topics/fable.md>), [HTML](<https://devfeed.tech/topics/html.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [fable](<https://devfeed.tech/tags/fable.md>), [html](<https://devfeed.tech/tags/html.md>), [info](<https://devfeed.tech/tags/info.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [readability](<https://devfeed.tech/tags/readability.md>), [specifications](<https://devfeed.tech/tags/specifications.md>)

### AI overview

The article compares Markdown, AsciiDoc, and HTML for AI specifications using document-size, markup-overhead, readability, and editing-workflow observations. It recommends Markdown for AI working documents, AsciiDoc for curated human-reviewed specifications, and HTML primarily as a publishing target.

### Source excerpt

I have a Spec Driven Project with 674 documents incl 181 specs, 429 tasks, and 40 project docs. About 1/3 of these are an acceptance sub-project to show the root project meets fit-for-purpose requirements. I used Fable to convert these to and from AsciiDoc, Markdown, and HTML. From this, I tried to draw some conclusions about which format is better than the others for AI specifications. TL;DR: Markdown for AI working documents, AsciiDoc for curated human-reviewed specs, HTML only as a publishing target. Objective Metrics Corpus Tokens (Approx) Markdown: 594k, AsciiDoc: 598K, HTML: 661k Worst Single-File Ratio AsciiDoc: 1.023x, HTML: 1.26x (due to tables and code blocks) Markup share of file content Markdown 0.9%, AsciiDoc 1.3%, HTML 9.9% - a 10x overhead for HTML Read/write Assessment In terms of readability, both Markdown and AsciiDoc are good. HTML has far more tags, which add noise. One of the most common tags is <code>some code</code> however in the other formats, this is just `some code` When you have an average of 16 per file, this adds a lot of noise. Usability GitHub renders both Markdown and AsciiDoc with working links and checkboxes; HTML is shown as raw source, so the review loop dies there. The first two are also easier to view while you're editing in IntelliJ. HTML is more difficult to read and edit, and it is not as easy to view the rendered output. If you occasionally need HTML, you don't need HTML files: embed an island with ```{=html} in Markdown (Pandoc raw-attribute syntax) or in AsciiDoc. It renders where HTML is supported and drops out cleanly elsewhere. If you really need to use HTML, you can include a link to a file in that format. Note As these were one-for-one conversions, I didn't use features that only exist in AsciiDoc or HTML, such as. Markdown vs AsciiDoc While you might choose either format for your specs, I have been following this convention to keep the authoring consistent. Markdown used for AI-generated content, not human-written,

## Why Is WCAG Level AA the Standard for Digital Accessibility?

DevFeed: [Why Is WCAG Level AA the Standard for Digital Accessibility?](<https://devfeed.tech/articles/why-is-wcag-level-aa-the-standard-for-digital-accessibility-36134.md>)

Original publisher: [Read original article](<https://www.boia.org/blog/why-is-wcag-level-aa-the-standard-for-digital-accessibility>)

Author: Mark

Published: 2026-03-06T16:56:18Z

Content type: article

Language: en

Sources: [Blog-Main](<https://devfeed.tech/sources/blog-main.md>)

Topics: [Accessibility](<https://devfeed.tech/topics/accessibility.md>), [Web Content Accessibility Guidelines](<https://devfeed.tech/topics/web-content-accessibility-guidelines.md>), [digital accessibility](<https://devfeed.tech/topics/digital-accessibility.md>), [Web Accessibility (a11y)](<https://devfeed.tech/topics/web-accessibility.md>), [Usability](<https://devfeed.tech/topics/usability.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [accessibility-guidelines](<https://devfeed.tech/tags/accessibility-guidelines.md>), [accessibility-requirements](<https://devfeed.tech/tags/accessibility-requirements.md>), [color](<https://devfeed.tech/tags/color.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [digital-accessibility](<https://devfeed.tech/tags/digital-accessibility.md>), [keyboard](<https://devfeed.tech/tags/keyboard.md>), [readability](<https://devfeed.tech/tags/readability.md>), [usability](<https://devfeed.tech/tags/usability.md>), [wcag](<https://devfeed.tech/tags/wcag.md>), [web-content-accessibility-guidelines](<https://devfeed.tech/tags/web-content-accessibility-guidelines.md>)

### AI overview

This article explains why WCAG Level AA is commonly used as the goal for digital accessibility. It contrasts Levels A, AA, and AAA, describing Level A as a baseline and highlighting Level AA requirements such as color contrast and visible focus.

### Source excerpt

When you're building an accessibility initiative, it's a good idea to establish your goals up front -- and most accessibility experts will tell you that means seeking Level AA conformance with the Web Content Accessibility Guidelines (WCAG).

## Practical Ways to Use AI in a Mobile Development Workflow

DevFeed: [Practical Ways to Use AI in a Mobile Development Workflow](<https://devfeed.tech/articles/microdosing-ai-for-mobile-dev-27346.md>)

Original publisher: [Read original article](<https://blog.mmckenna.me/microdosing-ai-for-mobile-dev>)

Author: Matt McKenna

Published: 2025-10-27T11:00:20Z

Content type: article

Language: en

Sources: [Matt McKenna](<https://devfeed.tech/sources/matt-mckenna.md>)

Topics: [Mobile](<https://devfeed.tech/topics/mobile.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Development](<https://devfeed.tech/topics/development.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Android](<https://devfeed.tech/topics/android.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Compose](<https://devfeed.tech/topics/compose.md>), [modules](<https://devfeed.tech/topics/modules.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [android](<https://devfeed.tech/tags/android.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [compose](<https://devfeed.tech/tags/compose.md>), [dev](<https://devfeed.tech/tags/dev.md>), [development](<https://devfeed.tech/tags/development.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [modules](<https://devfeed.tech/tags/modules.md>), [readability](<https://devfeed.tech/tags/readability.md>)

### AI overview

A developer describes practical uses of AI in mobile development, including locating UI strings from screenshots, performing preliminary code reviews, identifying unused resources, and generating regular expressions for file searches. The article presents AI as a tool for workflow support rather than code replacement.

### Source excerpt

I've been experimenting with small, practical ways AI can fit into my daily mobile development. Not to write code for me, but to accelerate the "in-between" steps of my workflow. These little uses aren't super flashy. They just smooth out some pain p...

## What Is Linting?

DevFeed: [What Is Linting?](<https://devfeed.tech/articles/what-is-linting-4505.md>)

Original publisher: [Read original article](<https://feeds.feedblitz.com/~/921146306/0/baeldung/cs>)

Author: John Caleb

Published: 2025-07-04T04:23:28Z

Content type: tutorial

Language: en

Sources: [Baeldung - CS](<https://devfeed.tech/sources/baeldung-cs.md>)

Topics: [developer tooling](<https://devfeed.tech/topics/developer-tooling.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [code-analysis](<https://devfeed.tech/tags/code-analysis.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [compilers-and-linkers](<https://devfeed.tech/tags/compilers-and-linkers.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lint](<https://devfeed.tech/tags/lint.md>), [linter](<https://devfeed.tech/tags/linter.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-compilers-and-linkers](<https://devfeed.tech/tags/programming-compilers-and-linkers.md>), [quality-control](<https://devfeed.tech/tags/quality-control.md>), [readability](<https://devfeed.tech/tags/readability.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

This tutorial explains what linting is, why linters are useful in software development, and how they detect syntax, semantic, formatting, and coding-style problems. It describes parsing source code into an abstract syntax tree and applying rules to identify issues such as undefined variables and incorrect code usage.

### Source excerpt

Explore linters, tools for automated code analysis that can capture syntactic, semantic, and stylistic errors in code. The post What Is Linting? first appeared on Baeldung on Computer Science. Related Stories How to Start Building an Operating System Raft Consensus Algorithm What Is a Monad?

## Writing Clear, Focused Assertions in Unit Tests

DevFeed: [Writing Clear, Focused Assertions in Unit Tests](<https://devfeed.tech/articles/the-1-mistake-in-unit-testing-and-how-to-fix-it-26213.md>)

Original publisher: [Read original article](<https://craftbettersoftware.com/p/the-1-mistake-in-unit-testing-and>)

Author: Daniel Moka

Published: 2025-05-24T05:01:11Z

Content type: tutorial

Language: en

Sources: [Craft Better Software](<https://devfeed.tech/sources/craft-better-software.md>)

Topics: [Testing](<https://devfeed.tech/topics/testing.md>), [Unit testing](<https://devfeed.tech/topics/unit-testing.md>), [clean-code](<https://devfeed.tech/topics/clean-code.md>)

Tags: [best-practices](<https://devfeed.tech/tags/best-practices.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [readability](<https://devfeed.tech/tags/readability.md>), [techniques](<https://devfeed.tech/tags/techniques.md>), [testing](<https://devfeed.tech/tags/testing.md>), [unit-testing](<https://devfeed.tech/tags/unit-testing.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The article presents five practices for writing clean, expressive assertions in unit tests. It emphasizes testing one logical behavior per test, capturing domain knowledge through well-named helper functions, and treating tests as documentation.

### Source excerpt

Best practices to nail the most important part of your unit test

## Choosing Wisely: for vs. forEach in Kotlin (A Thinking Dev's Perspective)

DevFeed: [Choosing Wisely: for vs. forEach in Kotlin (A Thinking Dev's Perspective)](<https://devfeed.tech/articles/choosing-wisely-for-vs-foreach-in-kotlin-a-thinking-dev-s-perspective-24905.md>)

Original publisher: [Read original article](<https://blog.blundellapps.co.uk/choosing-wisely-for-vs-foreach-in-kotlin-a-thinking-devs-perspective/>)

Author: blundell

Published: 2025-04-04T14:25:30Z

Content type: article

Language: en

Sources: [Blundell](<https://devfeed.tech/sources/blundell.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [androiddev](<https://devfeed.tech/tags/androiddev.md>), [code](<https://devfeed.tech/tags/code.md>), [dev](<https://devfeed.tech/tags/dev.md>), [foreach](<https://devfeed.tech/tags/foreach.md>), [functional](<https://devfeed.tech/tags/functional.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [loops](<https://devfeed.tech/tags/loops.md>), [programming](<https://devfeed.tech/tags/programming.md>), [readability](<https://devfeed.tech/tags/readability.md>), [reference](<https://devfeed.tech/tags/reference.md>), [reference-androiddev-kotlin](<https://devfeed.tech/tags/reference-androiddev-kotlin.md>), [structure](<https://devfeed.tech/tags/structure.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

This Kotlin development article argues against reflexively choosing forEach. It compares forEach with traditional for loops and dedicated functional operators, emphasizing readability, explicit control, side effects, and clearer data flow.

### Source excerpt

The forEach loop, are you using it without thinking? In Kotlin, empirically forEach is often the go-to loop, it's pragmatically close at reach in the IDE auto-complete, but is it always the right choice? This post argues that for loops deserve more consideration, offering clarity and control that forEach sometimes lacks. Let's discuss why a [...] The post Choosing Wisely: for vs. forEach in Kotlin (A Thinking Dev's Perspective) first appeared on Blundell.

## Make regular expressions easier to read

DevFeed: [Make regular expressions easier to read](<https://devfeed.tech/articles/make-regular-expressions-easier-to-read-37309.md>)

Original publisher: [Read original article](<https://muffinman.io/blog/make-regular-expressions-easier-to-read/>)

Author: Stanko

Published: 2025-03-31T00:00:00Z

Content type: tutorial

Language: en

Sources: [Stanko Tadić](<https://devfeed.tech/sources/stanko-tadic.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [formatting](<https://devfeed.tech/topics/formatting.md>), [Maintainability](<https://devfeed.tech/topics/maintainability.md>)

Tags: [example](<https://devfeed.tech/tags/example.md>), [extra](<https://devfeed.tech/tags/extra.md>), [join](<https://devfeed.tech/tags/join.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [readability](<https://devfeed.tech/tags/readability.md>), [regular-expressions](<https://devfeed.tech/tags/regular-expressions.md>), [value](<https://devfeed.tech/tags/value.md>)

### AI overview

The article presents a formatting technique for making complex regular expressions easier to read: split the expression into multiple string components, join them, and construct the final regex. The approach adds code and requires escaping backslashes, but enables scanning and comments that can improve readability and maintainability.

### Source excerpt

This is a simple formatting trick I use to make regular expressions more readable. The secret? Break them into multiple lines. To achieve this, format the regex as an array of strings and then concatenate the array into a single regex string. Example # Compare this example, written in a single line: const FILTER_REGEXP = /(?<name>blur|brightness|contrast|grayscale|hue-rotate|invert|opacity|saturate|sepia)\((?<value>-?\d*(?:\.\d*)?)(?<unit>\w*?)\)/g; with the multi-line version: const SUPPORTED_FILTERS = [ 'blur', 'brightness', 'contrast', 'grayscale', 'hue-rotate', 'invert', 'opacity', 'saturate', 'sepia', ].join('|'); const FILTER_REGEXP = new RegExp( [ `(?<name>${SUPPORTED_FILTERS})`, // filter name `\\(`, `(?<value>\-?\\d*(?:\\.\\d*)?)`, // value `(?<unit>\\w*?)`, // unit if any `\\)`, ].join(''), 'g' ); The multi-line version has a bit more code, but it's easier to scan and read. It also allows us to write comments for each section, clarifying the purpose of each part of the regex. I've found that complex expressions are much easier to write this way. I believe it greatly reduces the cognitive load for both the writer and the reader. Caveats # You'll need to escape the backslashes in regex strings. While this is a minor inconvenience, the readability benefits easily outweigh it. Conclusion # It boils down to personal preference, but I believe the extra code is worth it, as it improves readability and maintainability. This is especially true when dealing with notoriously difficult-to-parse complex regular expressions.

## Programming Priorities

DevFeed: [Programming Priorities](<https://devfeed.tech/articles/programming-priorities-38390.md>)

Original publisher: [Read original article](<https://blog.danlew.net/2025/03/11/programming-priorities/>)

Author: Dan Lew

Published: 2025-03-11T14:00:44Z

Content type: opinion

Language: en

Sources: [Dan Lew Blog](<https://devfeed.tech/sources/dan-lew-blog.md>)

Topics: [Maintainability](<https://devfeed.tech/topics/maintainability.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Development](<https://devfeed.tech/topics/development.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [code](<https://devfeed.tech/tags/code.md>), [code-design](<https://devfeed.tech/tags/code-design.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [development](<https://devfeed.tech/tags/development.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [programming](<https://devfeed.tech/tags/programming.md>), [readability](<https://devfeed.tech/tags/readability.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

This article presents a priority order for code design: functionality first, maintainability second, and other concerns afterward. It argues that maintainable code reduces the time and risk involved in future changes, allowing later refactoring and optimization. Suggested practices include automated tests, good architecture, decoupling, encapsulation, readable code, and useful comments.

### Source excerpt

Software development (or, you know, life in general) is all about juggling priorities. For this post, I'm thinking specifically about code design priorities. You only have a limited amount of time to implement a feature, so you have to pick and choose which aspects of it to spend

## Arrange Your Code to Communicate Data Flow

DevFeed: [Arrange Your Code to Communicate Data Flow](<https://devfeed.tech/articles/arrange-your-code-to-communicate-data-flow-23863.md>)

Original publisher: [Read original article](<http://testing.googleblog.com/2025/01/arrange-your-code-to-communicate-data.html>)

Author: Google Testing Bloggers (noreply@blogger.com)

Published: 2025-01-07T13:59:00Z

Content type: tutorial

Language: en

Sources: [Google Testing Blog](<https://devfeed.tech/sources/google-testing-blog.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [code](<https://devfeed.tech/tags/code.md>), [code-health](<https://devfeed.tech/tags/code-health.md>), [cognitive-load](<https://devfeed.tech/tags/cognitive-load.md>), [readability](<https://devfeed.tech/tags/readability.md>), [sebastian-dorner](<https://devfeed.tech/tags/sebastian-dorner.md>), [tott](<https://devfeed.tech/tags/tott.md>)

### AI overview

The article explains how arranging adjacent lines of code to follow data flow can improve readability and reduce cognitive load. It uses sandwich-making examples to show grouping related operations, adding blank lines between code blocks, and handling values reused for logging.

### Source excerpt

This article was adapted from a Google Tech on the Toilet (TotT) episode. You can download a printer-friendly version of this TotT episode and post it in your office. By Sebastian Dörner We often read code linearly, from one line to the next. To make code easier to understand and to reduce cognitive load for your readers, make sure that adjacent lines of code are coherent. One way to achieve this is to order your lines of code to match the data flow inside your method: fun getSandwich( bread: Bread, pasture: Pasture ): Sandwich { // This alternates between milk- // bread-related code. val cow = pasture.getCow() val slicedBread = bread.slice() val milk = cow.getMilk() val toast = toastBread(slicedBread) val cheese = makeCheese(milk) return Sandwich(cheese, toast) } fun getSandwich( bread: Bread, pasture: Pasture ): Sandwich { // Linear flow from cow to milk // to cheese. val cow = pasture.getCow() val milk = cow.getMilk() val cheese = makeCheese(milk) // Linear flow from bread to slicedBread // to toast. val slicedBread = bread.slice() val toast = toastBread(slicedBread) return Sandwich(cheese, toast) } To visually emphasize the grouping of related lines, you can add a blank line between each code block. Often you can further improve readability by extracting a method, e.g., by extracting the first 3 lines of the function on the above right into a getCheese method. However, in some scenarios, extracting a method isn't possible or helpful, e.g., if data is used a second time for logging. If you order the lines to match the data flow, you can still increase code clarity: fun getSandwich(bread: Bread, pasture: Pasture): Sandwich { // Both milk and cheese are used below, so this can't easily be extracted into // a method. val cow = pasture.getCow() val milk = cow.getMilk() reportFatContentToStreamz(cow.age, milk) val cheese = makeCheese(milk) val slicedBread = bread.slice() val toast = toastBread(slicedBread) logWarningIfAnyExpired(bread, toast, milk, cheese) return Sand

## Ep. 1: Mastering Software Design: Architectural Layers and Coding Modes

DevFeed: [Ep. 1: Mastering Software Design: Architectural Layers and Coding Modes](<https://devfeed.tech/articles/ep-1-mastering-software-design-architectural-layers-and-coding-modes-22238.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/05/mastering-software-design-architectural-layers-and-coding-modes-ep-1.html>)

Published: 2024-05-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [coding-modes](<https://devfeed.tech/tags/coding-modes.md>), [go](<https://devfeed.tech/tags/go.md>), [go-development](<https://devfeed.tech/tags/go-development.md>), [go-projects](<https://devfeed.tech/tags/go-projects.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [readability](<https://devfeed.tech/tags/readability.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [software-design](<https://devfeed.tech/tags/software-design.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [ultimate-software-design-series](<https://devfeed.tech/tags/ultimate-software-design-series.md>), [writing-code](<https://devfeed.tech/tags/writing-code.md>)

### AI overview

This episode of the Ultimate Software Design series explains how to create clear, precise, robust, and maintainable code in Go. It covers readability, semantic precision in components, functions, and variables, the distinction between programming and engineering modes, and systematic refactoring focused on precision, testability, and readability.

### Source excerpt

Introduction: Embark on a journey into the heart of software design with the Ultimate Software Design series, where Bill navigates through the intricacies of crafting robust and maintainable code in Go. Understand the importance of prioritizing clarity over brevity in code, fostering better understanding and collaboration among Go developers. Learn how to ensure precision in every aspect of Go development, emphasizing the necessity for precise semantic meanings in components, functions, and variables.

## Getting started with PHP static analysis in 2024

DevFeed: [Getting started with PHP static analysis in 2024](<https://devfeed.tech/articles/getting-started-with-php-static-analysis-in-2024-7939.md>)

Original publisher: [Read original article](<https://snyk.io/blog/getting-started-php-static-analysis-2024/>)

Author: Liran Tal

Published: 2024-03-21T05:00:00Z

Content type: article

Language: en

Sources: [Blog RSS Feed | Snyk](<https://devfeed.tech/sources/blog-rss-feed-snyk.md>)

Topics: [PHP](<https://devfeed.tech/topics/php.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Security](<https://devfeed.tech/topics/security.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [debug](<https://devfeed.tech/topics/debug.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>)

Tags: [awareness](<https://devfeed.tech/tags/awareness.md>), [blog](<https://devfeed.tech/tags/blog.md>), [code-security](<https://devfeed.tech/tags/code-security.md>), [developer](<https://devfeed.tech/tags/developer.md>), [devrel](<https://devfeed.tech/tags/devrel.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [php](<https://devfeed.tech/tags/php.md>), [production](<https://devfeed.tech/tags/production.md>), [readability](<https://devfeed.tech/tags/readability.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [security](<https://devfeed.tech/tags/security.md>), [security-vulnerabilities](<https://devfeed.tech/tags/security-vulnerabilities.md>), [snyk-code](<https://devfeed.tech/tags/snyk-code.md>), [web-development](<https://devfeed.tech/tags/web-development.md>)

### AI overview

This article introduces static analysis for PHP development. It explains how examining PHP source code without executing it can detect errors, security vulnerabilities, coding-standard violations, and complex code early, helping developers improve code quality before deployment.

### Source excerpt

In this post, we cover the basics of static analysis and how to secure your PHP code in 2024.

## Blazing ahead with 22

DevFeed: [Blazing ahead with 22](<https://devfeed.tech/articles/blazing-ahead-with-22-8752.md>)

Original publisher: [Read original article](<https://trino.io/blog/2024/03/13/java-22.html>)

Author: Manfred Moser, Martin Traverso, Dain Sundstrom, David Phillips

Published: 2024-03-13T00:00:00Z

Content type: article

Language: en

Sources: [Trino Blog](<https://devfeed.tech/sources/trino-blog.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [API](<https://devfeed.tech/topics/api.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [releases](<https://devfeed.tech/topics/releases.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [innovation](<https://devfeed.tech/tags/innovation.md>), [java](<https://devfeed.tech/tags/java.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [performance](<https://devfeed.tech/tags/performance.md>), [readability](<https://devfeed.tech/tags/readability.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

Trino plans to adopt and require Java 22 for building and running the project. The move is intended to improve performance and runtime behavior, modernize the codebase with newer language features and APIs, support Project Hummingbird work, and attract contributors. The article also outlines planned experimentation with several Java 22 JEPs, including Vector API, Structured Concurrency, Scoped Values, and the Foreign Function & Memory API.

### Source excerpt

It was not that long ago that we first announced support for Java 21, and subsequently made it a build and runtime requirement with Trino 436. Since then, the codebase received some significant improvements in readability, and we have also seen better performance. However, innovation in Trino and Java is not holding still, on the contrary - it's accelerating. On the Java community side, Java 22 is just about to be released, and we think it is time to drive innovation in Trino even further. Trino is going to use and require Java 22 soon!

## Multiline Expressions in Ansible Playbooks

DevFeed: [Multiline Expressions in Ansible Playbooks](<https://devfeed.tech/articles/multiline-expressions-in-ansible-playbooks-10953.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/03/ansible-multiline-expressions/>)

Published: 2024-03-06T06:33:00Z

Content type: tutorial

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

Topics: [Ansible](<https://devfeed.tech/topics/ansible.md>), [YAML](<https://devfeed.tech/topics/yaml.md>)

Tags: [ansible](<https://devfeed.tech/tags/ansible.md>), [readability](<https://devfeed.tech/tags/readability.md>), [release](<https://devfeed.tech/tags/release.md>), [yaml](<https://devfeed.tech/tags/yaml.md>)

### AI overview

This tutorial explains that multiline YAML formatting can add a trailing newline to Ansible expressions. In older Ansible core releases, that newline may cause an expression to be evaluated as a non-empty string and therefore as true. It recommends avoiding multiline YAML formatting in Ansible expressions or removing the trailing newline with quotes or a YAML block chomping indicator.

### Source excerpt

Another week, another Ansible quirk 🤷♂ Imagine you have a long Jinja2 expression, and you want to wrap it into multiple lines to improve readability. Using multiline YAML format seems to be the ideal choice: --- - name: Test playbook hosts: localhost tasks: - set_fact: a: > {{ 123 == 345 or 123 > 345 }} It works every time 50% of the time (this time depending on your Ansible version). Read more ...

## How to Write Code Comments That Improve Readability

DevFeed: [How to Write Code Comments That Improve Readability](<https://devfeed.tech/articles/let-code-speak-for-itself-23849.md>)

Original publisher: [Read original article](<http://testing.googleblog.com/2023/12/let-code-speak-for-itself.html>)

Author: Google Testing Bloggers (noreply@blogger.com)

Published: 2023-12-12T16:06:00Z

Content type: tutorial

Language: en

Sources: [Google Testing Blog](<https://devfeed.tech/sources/google-testing-blog.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [api-documentation](<https://devfeed.tech/tags/api-documentation.md>), [code](<https://devfeed.tech/tags/code.md>), [code-health](<https://devfeed.tech/tags/code-health.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [francois-aube](<https://devfeed.tech/tags/francois-aube.md>), [guide](<https://devfeed.tech/tags/guide.md>), [readability](<https://devfeed.tech/tags/readability.md>), [shiva-garg](<https://devfeed.tech/tags/shiva-garg.md>), [tott](<https://devfeed.tech/tags/tott.md>)

### AI overview

The article offers practical guidance for writing maintainable code: use comments to explain why an approach is taken, choose descriptive identifiers, document function purpose and meaning, and avoid comments about implementation details that may change.

### Source excerpt

This is another post in our Code Health series. A version of this post originally appeared in Google bathrooms worldwide as a Google Testing on the Toilet episode. You can download a printer-friendly version to display in your office. by Shiva Garg and Francois Aube Comments can be invaluable for understanding and maintaining a code base. But excessive comments in code can become unhelpful clutter full of extraneous and/or outdated detail. Comments that offer useless (or worse, obsolete) information hurt readability. Here are some tips to let your code speak for itself: Write comments to explain the "why" behind a certain approach in code. The comment below has two good reasons to exist: documenting non-obvious behavior and answering a question that a reader is likely to have (i.e. why doesn't this code render directly on the screen?): // Eliminate flickering by rendering the next frame off-screen and swapping into the // visible buffer. RenderOffScreen(); SwapBuffers(); Use well-named identifiers to guide the reader and reduce the need for comments: // Payout should not happen if the user is // in an ineligible country. std::unordered_set<std::string> ineligible = {"Atlantis", "Utopia"}; if (!ineligible.contains(country)) { Payout(user.user_id); } if (IsCountryEligibleForPayout(country)) { Payout(user.user_id); } Write function comments (a.k.a. API documentation) that describe intended meaning and purpose, not implementation details. Choose unambiguous function signatures that callers can use without reading any documentation. Don't explain inner details that could change without affecting the contract with the caller: // Reads an input string containing either a // number of milliseconds since epoch or an // ISO 8601 date and time. Invokes the // Sole, Laces, and ToeCap APIs, then // returns an object representing the Shoe // available then or nullptr if none were. Shoe* ModelAvailableAt(char* time); // Returns the Shoe that was available for // purchase at `time`

## Implementing Enumerations In Go

DevFeed: [Implementing Enumerations In Go](<https://devfeed.tech/articles/implementing-enumerations-in-go-22228.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2023/09/implementing-enumerations-in-golang.html>)

Published: 2023-09-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [C#](<https://devfeed.tech/topics/csharp.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [enumeration](<https://devfeed.tech/tags/enumeration.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [implement](<https://devfeed.tech/tags/implement.md>), [readability](<https://devfeed.tech/tags/readability.md>)

### AI overview

A tutorial on implementing enumeration-like types in Go. It compares Go's lack of native enumerations with C# enumerations and presents a struct-based pattern intended to provide compiler protection and improve type safety for a defined set of string values.

### Source excerpt

Introduction Prior to coding in Go, I was writing software in C#. In C# enumerations can be declared and the associated type can be used in functions and as fields in a struct. The compiler won't allow a value of the enumerated type to be passed or set that doesn't belong to the defined set. This is something that I have missed since coding in Go. Go doesn't have enumerations and it can be a problem at times when you want type safety for a well-defined set of values. A common way people try to have enumerations in Go really doesn't work for me because of the way constants behave. That being said, I have developed a pattern that gets me as close as possible to what I had in C# though it's not perfect and I will explain.

## On the Road to Effective Data Analyses

DevFeed: [On the Road to Effective Data Analyses](<https://devfeed.tech/articles/on-the-road-to-effective-data-analyses-20039.md>)

Original publisher: [Read original article](<https://technology.doximity.com/articles/on-the-road-to-effective-data-analyses>)

Author: Doximity

Published: 2023-09-07T16:45:00Z

Content type: tutorial

Language: en

Sources: [Doximity](<https://devfeed.tech/sources/doximity.md>)

Topics: [Data analysis](<https://devfeed.tech/topics/data-analysis.md>), [coding](<https://devfeed.tech/topics/coding.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [data](<https://devfeed.tech/tags/data.md>), [data-analyst](<https://devfeed.tech/tags/data-analyst.md>), [python](<https://devfeed.tech/tags/python.md>), [readability](<https://devfeed.tech/tags/readability.md>), [review](<https://devfeed.tech/tags/review.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

This article presents practical guidance for making data analyses more compelling and useful. It recommends breaking broad product questions into specific data questions, collaborating early to identify potential data issues, and writing readable, reviewable code using SQL common table expressions and Python functions.

### Source excerpt

In the modern business landscape, the significance of data analysis cannot be overstated. It empowers organizations to uncover insights, make informed decisions, and gain a competitive edge by deciphering the hidden patterns within vast datasets. Data analysis is the cornerstone of strategic innovation and effective decision-making in today's dynamic markets. At Doximity, data is crucial to the success of business operations, playing a key role in every step of the product development cycle. From determining the potential of new features to testing and tracking their performance, data analysts and business intelligence analysts are critical to Doximity's success. Data analysts are equipped with powerful data analysis tools. While the variety of tools makes data analysis enjoyable, it still requires practice and self-reflection to create engaging analyses that cater to their audience. Here are a few tips for making analyses more compelling and useful. Ask the right questions from your data Every data analysis begins with an open-ended product question, which must be broken down into more specific questions related to the data. Taking the time to structure the analysis with well-defined questions can prevent analysts from getting lost in unnecessary details. Brainstorming early with colleagues and product managers can provide valuable insights and help identify and avoid potential data issues that could lead to flawed findings. As an example, consider the open-ended production question - "Why is the engagement with component x of our app increasing/decreasing in the last 2 months?" Upon brainstorming, this leads to questions "closer" to the data, such as: Is this a local high/low or an all-time high/low? In particular, have we seen seasonality with this metric in recent years? Is there a competing component of the app whose engagement has gone down/up in recent times that is correlated with this component's engagement going up/down? Write readable code Although coding

## Organize your Views: SwiftUI edition

DevFeed: [Organize your Views: SwiftUI edition](<https://devfeed.tech/articles/organize-your-views-swiftui-edition-25574.md>)

Original publisher: [Read original article](<https://www.marcogomiero.com/posts/2023/organize-view-swiftui-edition/>)

Author: Marco Gomiero

Published: 2023-03-23T00:00:00Z

Content type: tutorial

Language: en

Sources: [Posts on Marco Gomiero](<https://devfeed.tech/sources/posts-on-marco-gomiero.md>)

Topics: [SwiftUI](<https://devfeed.tech/topics/swiftui.md>), [ui](<https://devfeed.tech/topics/ui.md>), [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Kotlin Multiplatform](<https://devfeed.tech/topics/kotlin-multiplatform.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [components](<https://devfeed.tech/tags/components.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [readability](<https://devfeed.tech/tags/readability.md>), [state](<https://devfeed.tech/tags/state.md>), [stateless](<https://devfeed.tech/tags/stateless.md>), [swift](<https://devfeed.tech/tags/swift.md>), [swiftui](<https://devfeed.tech/tags/swiftui.md>), [ui](<https://devfeed.tech/tags/ui.md>), [ui-components](<https://devfeed.tech/tags/ui-components.md>)

### AI overview

This tutorial explains how to organize SwiftUI views in a Kotlin Multiplatform money-management app. It recommends keeping each screen's entry-point view small, splitting UI into reusable components, hoisting state so views remain stateless, and isolating ViewModel and external-dependency connections. The author reports improved readability and maintainability.

### Source excerpt

One of the pros of SwiftUI, and generally of declarative UI frameworks, is the capability of defining the UI with the same programming language the application uses. With SwiftUI, it is not necessary anymore to bridge the UI definitions from somewhere else, resulting in a decrease of context switching between two different environments (Storyboards and Swift code, for example) But "with great power comes great responsibility", and a codebase can quickly become a nightmare without some structure and organization. Long files, large structs, and stateful UI components that hinder reusability are examples that can lead to a messed codebase.

## Astro unveils a refreshed brand identity, including a new logo, typography, color palette, and illustration style

DevFeed: [Astro unveils a refreshed brand identity, including a new logo, typography, color palette, and illustration style](<https://devfeed.tech/articles/welcome-world-3351.md>)

Original publisher: [Read original article](<https://astro.build/blog/welcome-world/>)

Author: Mark Peck

Published: 2023-03-06T00:00:00Z

Content type: release

Language: en

Sources: [The Astro Blog](<https://devfeed.tech/sources/the-astro-blog.md>)

Topics: [Astro](<https://devfeed.tech/topics/astro.md>), [Development](<https://devfeed.tech/topics/development.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>)

Tags: [astro](<https://devfeed.tech/tags/astro.md>), [color](<https://devfeed.tech/tags/color.md>), [design](<https://devfeed.tech/tags/design.md>), [palette](<https://devfeed.tech/tags/palette.md>), [readability](<https://devfeed.tech/tags/readability.md>), [typography](<https://devfeed.tech/tags/typography.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

Astro introduces a refreshed brand identity shaped through community interviews and a design process with Streiloff & Co. The update includes refinements to its logo, new typefaces, a distinctive color palette, and an original illustration style.

### Source excerpt

Astro's new look is live! Learn all about our new brand including the design process, our new logo, typeface, color palette, and mascot.

## Basic values in Kotlin

DevFeed: [Basic values in Kotlin](<https://devfeed.tech/articles/basic-values-in-kotlin-39341.md>)

Original publisher: [Read original article](<https://kt.academy/article/kfde-values>)

Published: 2023-02-27T00:01:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [format](<https://devfeed.tech/tags/format.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [literals](<https://devfeed.tech/tags/literals.md>), [number](<https://devfeed.tech/tags/number.md>), [operations](<https://devfeed.tech/tags/operations.md>), [precision](<https://devfeed.tech/tags/precision.md>), [readability](<https://devfeed.tech/tags/readability.md>), [types](<https://devfeed.tech/tags/types.md>), [values](<https://devfeed.tech/tags/values.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This tutorial introduces Kotlin's basic value types and literals, including numbers, booleans, characters, strings, and arrays. It explains Kotlin's object model, compiler optimization of some types, numeric ranges and precision, explicit type conversions, and underscore formatting in number literals.

### Source excerpt

Learn about the basic Kotlin values, types and operations.

## Effective Kotlin Item 10: Design for readability

DevFeed: [Effective Kotlin Item 10: Design for readability](<https://devfeed.tech/articles/effective-kotlin-item-10-design-for-readability-39288.md>)

Original publisher: [Read original article](<https://kt.academy/article/ek-readability>)

Published: 2022-10-24T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Kotlin programming](<https://devfeed.tech/topics/kotlin-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [cognitive-load](<https://devfeed.tech/tags/cognitive-load.md>), [effective](<https://devfeed.tech/tags/effective.md>), [elvis-operator](<https://devfeed.tech/tags/elvis-operator.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [junior](<https://devfeed.tech/tags/junior.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [programming](<https://devfeed.tech/tags/programming.md>), [readability](<https://devfeed.tech/tags/readability.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This article explains why code readability matters in Kotlin, emphasizing that developers spend much more time reading code than writing it. It argues that fewer lines or characters do not necessarily make code easier to understand, and that readability depends on cognitive load and familiarity with programming idioms, especially for less experienced Kotlin developers.

### Source excerpt

Do we really want out applications concise, or do we rather want them readable?

## Measuring the Impact of Font Grade on Text Readability

DevFeed: [Measuring the Impact of Font Grade on Text Readability](<https://devfeed.tech/articles/adjusting-grade-for-mode-29309.md>)

Original publisher: [Read original article](<https://material.io/blog/readability-research>)

Published: 2022-05-11T09:00:00Z

Content type: article

Language: en

Sources: [Material.io - Material Design](<https://devfeed.tech/sources/material-io-material-design.md>)

Topics: [Font](<https://devfeed.tech/topics/font.md>)

Tags: [measuring](<https://devfeed.tech/tags/measuring.md>), [readability](<https://devfeed.tech/tags/readability.md>), [text](<https://devfeed.tech/tags/text.md>)

### AI overview

This article examines how font grade affects text readability.

### Source excerpt

Measuring the impact font grade has on text readability

## Everyday Accessibility

DevFeed: [Everyday Accessibility](<https://devfeed.tech/articles/everyday-accessibility-9382.md>)

Original publisher: [Read original article](<https://a11yproject.com/posts/everyday-accessibility/>)

Author: Michele A Williams; PhD

Published: 2021-06-15T00:00:00Z

Content type: article

Language: en

Sources: [The A11Y Project](<https://devfeed.tech/sources/the-a11y-project.md>)

Topics: [Accessibility](<https://devfeed.tech/topics/accessibility.md>), [alt text](<https://devfeed.tech/topics/alt-text.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [alt-text](<https://devfeed.tech/tags/alt-text.md>), [images](<https://devfeed.tech/tags/images.md>), [readability](<https://devfeed.tech/tags/readability.md>), [social-media](<https://devfeed.tech/tags/social-media.md>), [speech](<https://devfeed.tech/tags/speech.md>), [text-to-speech](<https://devfeed.tech/tags/text-to-speech.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

This practical accessibility article explains how to make social media, digital, and multimedia content more inclusive. It recommends capitalizing words in hashtags, providing written text alongside images of text, adding concise alt text to images, limiting disruptive emoji use, and using built-in document styling features so assistive technologies can interpret content correctly.

### Source excerpt

Even with the best of intentions, you may be making decisions that exclude disabled users. Below are practical, intentional steps you can start today to create and share more accessible social media, digital, and multimedia content. Watch this post as a video Social Media Posts Social media is central to the world's conversations, so ensure you're not leaving anyone out. Use capital letters in hashtags Punctuation helps text-to-speech tools like screen readers speak more accurately, and helps with readability overall. This includes in hashtags, where capital letters help distinguish words. Key Point: Make it a habit to #UseCapitalLetters rather than #hardtoreadlowercase. Don't share just images of text Images of text (such as your favorite quote or saying) can be difficult for people with visual impairments to read and don't allow people with reading difficulties to leverage text-to-speech read-aloud features. When posting these kinds of images, also write out the text in your post. Key Point: Typing out the text in an image makes the content more accessible. Use "alt text" features to describe images Pictures are significant in social media, but also inaccessible to visually impaired readers unless they have a text-based description. When uploading, find the "image description" or "alternative/alt text" feature in the software to write a description. For sample instructions, review Alt Text for Social Media. When adding descriptions, don't write every detail, just enough to ensure everyone can understand your post and share in the image's meaning. For examples, read Scott Vinkle's Considerations when writing alt text. Key Point: Features like Twitter's "Add description" allow adding "alt text" for visually impaired readers. Limit your emojis Emojis are great for emphasis and playfulness, but adding too many sounds cluttered with text-to-speech software. Also, when placed unconventionally (such as throughout a sentence) this is distracting and hard to read for those

[Next page](<https://devfeed.tech/tags/readability.md?cursor=WyIyMDIxLTA2LTE1VDAwOjAwOjAwKzAwOjAwIiwgImNiNGI2OWMwLTI0NGItNGE0My1hMzI0LWM1ZjhjM2Q4NmIwYSJd>)