# refactor Published articles for refactor. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## The Great Python Refactor of 2017 And Also 2018 DevFeed: [The Great Python Refactor of 2017 And Also 2018]() Original publisher: [Read original article]() Author: Khan Academy Published: 2018-03-19T22:00:00Z Content type: article Language: en Sources: [Khan Academy]() Topics: [Python](), [Refactoring](), [Code](), [Development](), [Tool]() Tags: [2017](), [blog-post](), [code](), [dev](), [engineering](), [infrastructure](), [news](), [python](), [refactor](), [refactoring]() ### AI overview This first article in a series describes Khan Academy's 2017-2018 Python refactoring effort. It explains how an overloaded codebase structure developed, the changes made to organize files and directories, and the difficulties of the work. ### Source excerpt By Craig Silverstein Our codebase was a mess. One day, we decided to do something about it: namely, ... Read more ## Untangling our Python Code DevFeed: [Untangling our Python Code]() Original publisher: [Read original article]() Author: Khan Academy Published: 2018-04-16T22:00:00Z Content type: tutorial Language: en Sources: [Khan Academy]() Topics: [Python](), [Code](), [import]() Tags: [code](), [dependencies](), [dependency](), [engineering](), [infrastructure](), [news](), [organization](), [python](), [refactor](), [structure]() ### AI overview This article explains how Khan Academy addressed tangled dependencies in its Python codebase during its 2017 and 2018 refactoring work. It describes why dependency order matters, the problems caused by circular and poorly organized imports, and the use of package-based rules to guide code organization and detect problematic dependencies. ### Source excerpt By Carter Bastian The previous posts about The Great Khan Academy Python Refactor of 2017 and Also 2018 ... Read more ## Refactoring Should NOT Touch Your Acceptance Tests DevFeed: [Refactoring Should NOT Touch Your Acceptance Tests]() Original publisher: [Read original article]() Author: Valentina Jemuović Published: 2026-09-03T06:00:37Z Content type: opinion Language: en Sources: [Optivem Journal]() Topics: [Refactoring](), [Pull Request](), [test]() Tags: [change](), [dsl](), [refactor](), [refactoring](), [test](), [tests]() ### AI overview The article argues that a refactoring pull request should not change acceptance tests or their DSL, because doing so changes behavior rather than merely restructuring code. ### Source excerpt A "refactor" PR that changes the acceptance test or the DSL isn't a refactor -- it's a behavioral change ## Nitpicking in code reviews wastes time DevFeed: [Nitpicking in code reviews wastes time]() Original publisher: [Read original article]() Author: Dan Lew Published: 2026-09-01T13:00:13Z Content type: opinion Language: en Sources: [Dan Lew Blog]() Topics: [Code](), [code productivity](), [Software Engineering](), [Development]() Tags: [bugs](), [code](), [code-reviews](), [development](), [features](), [problems](), [refactor](), [software-development](), [time]() ### AI overview An opinion article argues that nitpicking minor issues in code reviews wastes time. Small problems usually have limited impact, may never cause trouble, and can often be fixed later, so review effort should prioritize major problems, bugs, and features. ### Source excerpt I once wrote about how I've stopped nit-picking in code reviews, which improved the signal-to-noise ratio and helped everyone get along better. I'm back with a third reason to ditch the practice: nit-picking wastes time. By definition, nitpicks are about minor problems: ## Scheduling Claude Code for Nightly Repository Maintenance DevFeed: [Scheduling Claude Code for Nightly Repository Maintenance]() Original publisher: [Read original article]() Author: Eric Roby Published: 2026-07-28T12:03:08Z Content type: tutorial Language: en Sources: [Eric Roby]() Topics: [Claude Code](), [Security](), [Refactoring](), [ci](), [hooks](), [Code]() Tags: [automated](), [ci](), [claude-code](), [github-action](), [hooks](), [how-to](), [refactor](), [repo](), [security]() ### AI overview The article explains how to schedule Claude Code in headless mode for recurring repository maintenance. It recommends focused jobs for security sweeps, refactoring scans, and enhancement reviews, using structured JSON output and the --bare option for consistent scripted runs. ### Source excerpt How to schedule headless runs for nightly security sweeps, refactor scans, and enhancement ideas ## Your Architecture Doesn't Rot Overnight DevFeed: [Your Architecture Doesn't Rot Overnight]() Original publisher: [Read original article]() Author: Valentina Jemuović Published: 2026-07-07T06:00:37Z Content type: opinion Language: en Sources: [Optivem Journal]() Topics: [legacy](), [systems](), [Software](), [Test-driven development]() Tags: [architecture](), [business-logic](), [code](), [dependency](), [legacy](), [refactor](), [requirements]() ### AI overview The article explains how repeated convenience-driven decisions gradually weaken boundaries between business logic and infrastructure. It argues that architectural decay often remains hidden while the application works and tests pass, eventually making seemingly simple changes difficult to locate and implement. ### Source excerpt As deadlines become tighter, convenience starts winning. ## TDD in Legacy Code - Maintainable Component Tests - Backend DevFeed: [TDD in Legacy Code - Maintainable Component Tests - Backend]() Original publisher: [Read original article]() Author: Valentina Jemuović Published: 2026-07-02T06:02:41Z Content type: tutorial Language: en Sources: [Optivem Journal]() Topics: [Back end](), [Test-driven development](), [legacy]() Tags: [api](), [backend](), [component](), [erp](), [legacy](), [legacy-code](), [refactor](), [tdd](), [tests]() ### AI overview A tutorial on refactoring brittle backend component tests that are coupled to a backend API and ERP system, with the goal of making them more maintainable. ### Source excerpt Many Backend Teams write unmaintainable Backend Component Tests - coupled to the Backend API and ERP. I'll show you how to refactor these brittle tests. ## The Way of TDD DevFeed: [The Way of TDD]() Original publisher: [Read original article]() Author: Google Testing Bloggers (noreply@blogger.com) Published: 2026-03-10T12:24:00Z Content type: article Language: en Sources: [Google Testing Blog]() Topics: [Test-driven development](), [Test coverage](), [Development](), [Algorithm](), [Code]() Tags: [algorithm](), [article](), [bartosz-papis](), [bugs](), [code](), [development](), [quality](), [refactor](), [tdd](), [test](), [test-coverage](), [tests](), [tott]() ### AI overview This article explains Test-Driven Development as a red-green-refactor cycle: write a failing test, make it pass with minimal production code, and then refactor. It describes reported benefits and limitations, and demonstrates the process by modifying a voting algorithm to support abstentions. ### 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 Bartosz Papis Test-Driven Development (TDD) is the practice of working in a structured cycle where writing tests comes before writing production code. The process involves three steps, sometimes called the red-green-refactor cycle: Write a failing test Make the test pass by writing just enough production code Refactor the production code to meet your quality standards Research shows TDD has several benefits: it improves test coverage, reduces the number of bugs, increases confidence, and facilitates code reuse. This practice also helps reduce distractions and keep you in the flow. TDD also has its limitations and is not a silver bullet! See the Wikipedia article about TDD for a detailed explanation and references. Here is a short practical example. Assume you need to modify the following voting algorithm to support the option for voters to abstain: def outcome(ballots): if ballots.count(Vote.FOR) > len(ballots) / 2: return "Approved" return "Rejected" 1. We start by writing a failing test - as expected, the test doesn't even compile: def test_abstain_doesnt_count(self): self.assertEqual(outcome([Vote.FOR, Vote.FOR, Vote.AGAINST, Vote.ABSTAIN]), "Approved") 2. We fix the compilation error by including the missing enum option: class Vote(Enum): FOR = 1 AGAINST = 2 ABSTAIN = 3 Now that the test compiles, we fix the production code to get all tests passing: def outcome(ballots): if ballots.count(Vote.FOR) > (len(ballots) - ballots.count(Vote.ABSTAIN)) / 2: return "Approved" return "Rejected" 3. We now refactor the code to improve clarity, and complete an iteration of the TDD cycle: def outcome(ballots): counts = collections.Counter(ballots) return "Approved" if counts[Vote.FOR] > counts[Vote.AGAINST] else "Rejected" Learn more about TDD in the book Test Driven Development: By Example, by Kent Beck. ## The AI Multiplier: Where Developers Actually Get Leverage DevFeed: [The AI Multiplier: Where Developers Actually Get Leverage]() Original publisher: [Read original article]() Author: Brian Jenney Published: 2026-03-07T21:57:25Z Content type: opinion Language: en Sources: [Brian Jenney]() Topics: [Artificial Intelligence](), [AI-assisted coding](), [coding assistant](), [coding](), [Software]() Tags: [ai](), [autocomplete](), [coding](), [coding-assistant](), [context](), [developers](), [refactor](), [tests]() ### AI overview This commentary describes how software developers can gain leverage from AI through progressively more advanced usage. It outlines coding-assistant tasks such as generating functions, refactoring code, writing tests, and explaining errors, then discusses using AI as a planning partner to analyze systems, identify risks, and propose plans before code is written. ### Source excerpt Last night I met up with Alex Lau, the author of Keep Calm, Code On, while he was in San Francisco. ## Fusaka Update - Transaction Gas Limit Cap arrives with EIP-7825 DevFeed: [Fusaka Update - Transaction Gas Limit Cap arrives with EIP-7825]() Original publisher: [Read original article]() Author: Toni Wahrstätter Published: 2025-10-21T00:00:00Z Content type: article Language: en Sources: [Ethereum Foundation Blog]() Topics: [Ethereum](), [Transactions](), [Deployment](), [systems]() Tags: [batch](), [batching](), [deployment](), [ethereum](), [monitoring](), [parallel](), [refactor](), [research-development](), [transactions]() ### AI overview The Fusaka hard fork will introduce EIP-7825, capping gas per transaction at 2²⁴, approximately 16.78 million gas. The cap is already active on Holesky and Sepolia and will apply to Ethereum mainnet with Fusaka. It may affect very large transactions, batch operations, deployment scripts, transaction builders, and related infrastructure, while leaving the overall block gas limit and eth_call limits unchanged. ### Source excerpt Starting with the upcoming Fusaka hard fork, EIP-7825 introduces a per-transaction gas limit cap of 2²⁴ (~= 16.78 million gas). This change is already live on Holesky and Sepolia, and will activate on mainnet with Fusaka. Developers and users who rely on very large transactions should verify that... ## Getting Into Flow State with Agentic Coding DevFeed: [Getting Into Flow State with Agentic Coding]() Original publisher: [Read original article]() Author: Kaushik Gopal Published: 2025-07-23T07:15:47Z Content type: tutorial Language: en Sources: [Kaushik Gopal's Site]() Topics: [agentic-coding](), [Claude Code](), [ai-coding](), [Development](), [Code](), [Pull Request]() Tags: [agentic-coding](), [ai-coding](), [claude-code](), [openai](), [refactor](), [review](), [verify]() ### AI overview A developer documents a workflow for using Claude Code and other AI coding agents in production software development. The process emphasizes maintaining shared instructions, planning work explicitly, and organizing implementation into discrete pull requests so agents can resume tasks with sufficient context. ### Source excerpt I recently found myself in a deep state of flow while coding -- the kind where time melts away and you gain real clarity about the software you're building. The difference this time: I was using Claude Code primarily. If my recent posts are any indication, I've been experimenting a lot with AI coding -- not just with toy side projects, but high-stakes production code for my day job. I have a flow that I think works pretty well. I'm documenting it here as a way to hone my own process and, hopefully, benefit others as well. set the stage plan with the agent (no really 🤮) spawn your agents verify and refactor the final review Skeptics vs cynics Many of my friends and colleagues are understandably skeptical about AI's role in development. That's ok. That's actually good. We should be skeptical of anything that's upending our field with such ferociousness. We just shouldn't be cynical.1 Step 0: Set the stage # You know what'll definitely get you out of the flow? Having to constantly repeat basic instructions to your agent. "This is an Android app that does X, using the Y architecture..." "When styling the front end web client, only use tailwind css v4..." "Use `make test` to run a single test; `make tests` to run the entire test suite..." "To build the app without running lint use `make`..." ... These are all very important instructions that you shouldn't have to repeat to your agent every single time. Invest a little upfront in your master ai instructions file. It makes a big difference and gets you up and coding quickly with any agent. trivial to get started with claude /init these days Of course, I also recommend consolidating your ai instructions to a single source of truth, so you're not locked in with any single vendor. Step 1: Plan with the Agent # Update: Checkout my post ExecPlans. I now use OpenAI's Aaron Friel ExecPlans approach for this. I won't lie. The idea of this step did not exactly spark joy for me. There are times where I plan my code out in a neat list, but rarel ## Tactical Coding Assistants DevFeed: [Tactical Coding Assistants]() Original publisher: [Read original article]() Author: Pieter Tolsma Published: 2025-07-03T08:53:09Z Content type: opinion Language: en Sources: [Booking.com Development - Medium]() Topics: [Large Language Model](), [Development](), [Software Engineering](), [Architecture & Design](), [Refactoring](), [Claude](), [Artificial Intelligence]() Tags: [ai](), [claude](), [coding](), [coding-assistant](), [complexity](), [design](), [development](), [genai](), [llm](), [refactor](), [review](), [software-design]() ### AI overview The article compares tactical and strategic programming and applies that distinction to coding assistants. Drawing on the author's experience, it argues that assistants such as Gemini 2.5 Pro and Claude 3.7 can implement clearly specified tasks effectively, but may produce excessive complexity, duplicated behavior, and difficult-to-maintain code when used without architectural review. ### Source excerpt Over the past 15 months I have been actively working with LLM's in my job as a software engineer. I have had many moments where I thought singularity was here, but then almost immediately after I would see the agent fall flat on its face. I have become interested in figuring out when and why these new tools fail, in the hope that it can help me use these tools to their maximum potential while still keeping control over the quality of what I commit. In this short article, I want to expand on a recent observation. Generated using Gemini Imagen 4 In the book 'A Philosophy of Software Design' by John K. Ousterhout, a great analogy is made between two different modes of development: tactical and strategic programming. Tactical programming: this is a shortsighted approach focused on completing the immediate task as quickly as possible. Here, the primary goal is to make a feature or bug fix work in the most direct way. You can imagine what will happen if you have a team of engineers that only works like this: technical debt will pile up fast. Generated using Gemini Imagen 4 On the other side there is strategic programming: this involves a higher level of thinking. A strategic programmer is not finished when the feature is implemented. They take a step back and review the architecture, to see if any abstractions can be made. Does the current approach overcomplicate things? Can we refactor things? The focus here is on design, where the engineers main goal is to keep complexity at bay. These two analogies hooked onto what I thought about the current state of coding assistants. In my experience, some of the current (mid-2025) state of the art coding assistants (Gemini 2.5 pro, Claude 3.7) are extremely adept tactical programmers. Assuming you give them a clear description of what you need implemented, they will go ahead and do it for you (with quite a high success rate in my experience). We humans are limited by many things, such as the speed at which we can physically press k ## How To Refactor Legacy Code DevFeed: [How To Refactor Legacy Code]() Original publisher: [Read original article]() Author: Daniel Moka Published: 2025-04-12T05:01:26Z Content type: tutorial Language: en Sources: [Craft Better Software]() Topics: [Refactoring](), [Testing](), [Dependency injection](), [Test coverage](), [Mocking]() Tags: [dependency-injection](), [how-to](), [legacy-code](), [refactor](), [refactoring](), [testing](), [tests]() ### AI overview A six-step strategy for refactoring legacy code by breaking dependencies, using characterization and other testing techniques, achieving test coverage, and then changing the code. ### Source excerpt The art of making your code testable, testing it effectively, and refactoring it like a pro ## How to use generics to avoid duplications and make your code better DevFeed: [How to use generics to avoid duplications and make your code better]() Original publisher: [Read original article]() Author: Domenico Luciani Published: 2025-04-10T22:00:00Z Content type: tutorial Language: en Sources: [Domenico Luciani]() Topics: [generics](), [Go Language](), [interfaces](), [JSON:API](), [factory function](), [Code]() Tags: [create](), [generics](), [go](), [how-to](), [interfaces](), [like](), [refactor]() ### AI overview A Go tutorial explains how generics can reduce duplicated method implementations when multiple response structs must satisfy the same interfaces. It demonstrates applying a reusable generic response to JSON:API-formatted responses and adding a factory function for readability. ### Source excerpt I recently worked on a project that had a lot of code duplication due to repeated implementations of the same interfaces. I quickly realized it was a great opportunity to refactor... ## Why Tinybird Rebuilt Its Frontend Instead of Patching It DevFeed: [Why Tinybird Rebuilt Its Frontend Instead of Patching It]() Original publisher: [Read original article]() Author: Rafa Moreno, Alasdair Brown Published: 2024-07-19T00:00:00Z Content type: article Language: en Sources: [Tinybird]() Topics: [Front end](), [Code](), [User experience (UX)]() Tags: [code](), [engineering-excellence](), [frontend](), [refactor](), [ux]() ### AI overview Tinybird describes a complete frontend refactor, citing faster loads, better UX, and cleaner code as reasons for rebuilding instead of patching. ### Source excerpt We refactored the Tinybird frontend completely. Faster loads, better UX, cleaner code. Here's why we rebuilt instead of patched. ## Campground Pull Request DevFeed: [Campground Pull Request]() Original publisher: [Read original article]() Author: Kaushik Gopal Published: 2024-07-06T22:52:31Z Content type: opinion Language: en Sources: [Kaushik Gopal's Site]() Topics: [Pull Request](), [Code review](), [Code quality](), [Code]() Tags: [cleanup](), [code](), [code-quality](), [merge](), [pull-request](), [refactor](), [review](), [reviews](), [team]() ### AI overview The article proposes "Campground PRs": separate pull requests for refactoring and clarifying code before implementing a new feature. Because these changes should not alter functionality, they can improve estimates, simplify reviews, and gradually improve codebase quality. ### Source excerpt Before diving into a new feature, I always tell my team to scout the parts of the codebase that will need to change. As we explore, refactor for clarity. These cleanup changes get their own pull request1 (PR) before we touch the new feature. This PR shouldn't change functionality, just tidy up the existing code. This gives us a few big wins: Better estimates: We can estimate the feature's timeline more accurately now that we have a much better sense of what's about to change. Smoother reviews: Campground PRs are quicker to review, since no functionality has changed. Importantly, you don't clutter your feature PR with refactors or distracting changes -- prompting the ire of code reviewers. Codebase quality: You gradually increase the code quality of your codebase -- especially the parts that won't get touched by your feature PR but could use the love. This is not a new concept , you've probably seen versions of it before: Boy Scout Rule: Leave your codebase cleaner than you found it. Broken Windows: Fix small issues before they proliferate through your code base become big. I haven't found a popular name for this specific concept, so I've started calling them "Campground PRs". Don't just leave the code better after your feature, do it before hand. Got a better name? Let me know! Or merge request (MR), for the Gitlab folks. ↩︎ ## How Ownership and Impact Help Engineers Become Senior DevFeed: [How Ownership and Impact Help Engineers Become Senior]() Original publisher: [Read original article]() Author: Tiger Abrodi Published: 2024-05-14T05:56:49Z Content type: opinion Language: en Sources: [Saiyan Growth Letter]() Topics: [Programming](), [Refactoring](), [trust]() Tags: [communication](), [developers](), [ownership](), [productivity](), [programming](), [refactor](), [team](), [trust]() ### AI overview This commentary argues that becoming a senior engineer depends mainly on ownership and impact, supported by technical ability, communication, reliability, and teamwork. ### Source excerpt Two main ingredients: Ownership and Impact! ## Perils of duplicate finding DevFeed: [Perils of duplicate finding]() Original publisher: [Read original article]() Published: 2024-02-14T00:00:00Z Content type: article Language: en Sources: [Jake Wharton]() Topics: [Kotlin](), [Code](), [Java]() Tags: [code](), [kotlin](), [refactor]() ### AI overview A Kotlin article examines several ways to find duplicated integers in a collection. It explains why collection subtraction and MutableList.removeAll produce unexpected results, then refactors toward approaches that correctly track previously seen values. ### Source excerpt Given an array of integers ([1, 2, 3, 1, 3, 1]), find the elements which are duplicated. No, we're not interviewing. I'm trying to prevent a user from specifying a reserved value twice. Elsewhere in the file I already have duplicate detection for object tags. val dupes: Map> = widgets.groupBy(Widget::tag) .filterValues { it.size > 1 } I can do the same technique for the integer array with an identity function and grabbing the resulting keys. val dupes: Set = ints.groupBy { it } .filterValues { it.size > 1 } .keys This prints [1, 3]. So... done? Yes! But no, using the map seems wasteful, right? Attempt 1 My first attempt to avoid the map was to remove the set of integers from a list of them. This should result in a list of any duplicated elements. val dupes: List = ints.toList() - ints.toSet() No matter the content of ints, this will always print []. Why? The minus operator says that it "returns a list containing all elements of the original collection except the elements contained in the given elements collection". So it removes all occurrences of each element in the set from the list. This is some surprising behavior to hide behind an operator whose signature operates on an Iterable receiver and Collection argument. Attempt 2 Second attempt switches to MutableList.removeAll which takes a collection of elements. The MutableList.remove function only removes the first occurrence of an element, so this should remove the first occurrence of each element in the set. val dupes: List = ints.toMutableList() .apply { removeAll(ints.toSet()) } This once again prints []. But why? Kotlin made me a liar. MutableList.remove does indeed only remove the first occurrence of the element. MutableList.removeAll, however, removes all occurrences of each element in the supplied collection. That's quite the subtle asymmetry. There is no function for removing all occurrences of a single element. Nor a function to remove only the first occurrences of each elem ## Intermediate collection avoidance DevFeed: [Intermediate collection avoidance]() Original publisher: [Read original article]() Published: 2024-02-07T00:00:00Z Content type: article Language: en Sources: [Jake Wharton]() Topics: [Kotlin](), [IntelliJ IDEA](), [Code](), [Compose]() Tags: [benchmarks](), [compose](), [intellij](), [java](), [kotlin](), [memory](), [performance](), [refactor]() ### AI overview This article explains how to avoid intermediate iterators and collections in Kotlin collection operations. It presents fused string joining, array initialization, and pre-sized list initialization as shorter, faster approaches that can reduce allocations, while noting that indexed access is important for performance and that these techniques are best suited to controlled internal usage. ### Source excerpt Given a list of users, extract their names and join them into a comma-separated list. Kotlin's extension functions on collections make this trivial. users.map { it.name }.joinToString() Writing this in IntelliJ IDEA produces a "weak warning" offering advice. Call chain on collection type may be simplified An intention action will refactor the code for you to a more efficient form. users.joinToString() { it.name } Mapping the user to their name now occurs during construction of the joined string rather than as a discrete operation. The additional iterator and intermediate collection produced by the map is eliminated. This code is both shorter and faster, and the IDE helps you discover this superior form. Two similar fused operations that I like but which don't benefit from IDE advice are array and pre-sized list initialization with a lambda. If we wanted to create an array of our user's names, instead of doing users.map { it.name }.toTypedArray() we can use Array(users.size) { users[it].name } This again trades the intermediate iterator and collection within map for an indexed loop. Primitive array versions are also available. IntArray(users.size) { users[it].age } Arrays are not used too often. Mostly for memory-sensitive or performance-sensitive code, or when calling out to a Java API. Thankfully this lambda-accepting initializer is also available for pre-sized lists. MutableList(users.size) { users[it].name } Use this to initialize element default values, compute elements based on the index, or derive data from another source. In the case of deriving data, the source needs to support random access in order to actually result in a more efficient computation.1 If you use a list backed by an alternate structure (linked, persistent, etc.) performance will be abysmal. This technique works best for internal library usage and should not be used when you don't control the original list. Benchmark Score Error Units --------------------------------------------- ---------- - ## I still see LiveData - where are the Flows? DevFeed: [I still see LiveData - where are the Flows?]() Original publisher: [Read original article]() Published: 2023-07-30T19:38:36Z Content type: opinion Language: en Sources: [maiatoday]() Topics: [Kotlin](), [kotlin-coroutines](), [multiplatform](), [Dependency injection]() Tags: [code](), [coroutines](), [dependency-injection](), [flow](), [kotlin](), [kotlin-coroutines](), [live-data](), [main-thread](), [multiplatform](), [network](), [refactor](), [thread]() ### AI overview The article argues that LiveData is appropriate for observing UI state but is a poor fit for repositories because it is tied to the Android lifecycle and always runs on the main thread. It recommends using Kotlin Flows, particularly in repositories, because they support configurable dispatchers, richer operators, and multiplatform projects. ### Source excerpt Hammer and nail There is no doubt LiveData is an easy, lifecycle safe way to observe some state which needs to be displayed on the UI. It is just so easy to create and easy to update. It is easy to observe. I think that may be why people use it everywhere where they need a simple observation. This ok, no guilt, no harm .... for the UI layers .... but there are better solutions for domain and data layers. This is not the first time this topic has come up yet I still see Live Data in a repository offered as a good solution from time to time, in blog posts, samples and in books. I think it is a case of people think they only have a LiveData hammer. There are infact pitfalls if you use LiveData in a repository. I think it's an anti-pattern. But why not LiveData is lifecycle aware - do we need this in our repository? Repostitories are typically provided by dependency injection, they could be singletons and they don't need to know about the Android lifecycle. LiveData always runs on the main thread, you can't change this. This is not what we want in a repository. Repositories often work with different data sources which could involve network or disk access tasks. I would argue that you need to be able to run these kinds of tasks on the correct dispatcher if your libraries do not already do this. This is the deal breaker for me because you can cause jank in the UI if you do this incorrectly. LiveData does have some capabilities to combine and convert LiveData variables with MediatorLiveData but flows provide a wide variety of elegant operators to choose from. This is probably not a solid argument more a case of convenience. Lastly, one of the biggest reasons after the main thread argument, why I would advocate for converting all of the LiveData use to flows: flows are part of the Kotlin coroutines library. This means they run on any platform where Kotlin coroutines run. You can use them in a multiplatform project. Or to put it differently, if you use flows in your repository i ## Swampy Refactor: Converting Otto Bus to Flows DevFeed: [Swampy Refactor: Converting Otto Bus to Flows]() Original publisher: [Read original article]() Published: 2023-07-17T17:18:36Z Content type: tutorial Language: en Sources: [maiatoday]() Topics: [migration](), [Coroutines](), [deprecated](), [Code](), [RxJava](), [Kotlin](), [Git]() Tags: [code](), [coroutines](), [deprecated](), [flow](), [git](), [migration](), [otto-bus](), [refactor](), [rxjava](), [swampy]() ### AI overview This tutorial explains how to migrate an Android application from the deprecated Otto Bus event bus to Kotlin Flow. It presents an incremental, event-by-event process and notes that the work may require architectural refactoring, dependency-injection changes, and testing. ### Source excerpt The story starts I was wandering around my day job's code base and I happened on a time capsule - a pristine Java Activity studded with semi-colons, a snapshot of how we built things in 2014. All the member variables started with m and there was plenty of logic to update the screen and dictate actions. Despite being old, it's still used every day by users. Why would I change it? The Bus disappears Well, it got its data from a subscription to the Otto Bus. Otto Bus was deprecated in 2016. A blog post suggested migrating to RxJava, but since our code base standard now involves coroutines, Flows, and in some cases, LiveData, I decided to remove deprecated libraries and complete the partial migrations we started some time ago. This blog post summarizes how to migrate from Otto Bus to Flow. I've also created a Git repo with a simplified example that uses Otto Bus, with a conversion to Flow in the commit history. Check out the otto-bus tag for the working Otto Bus version and the flow tag for the converted Flow version. I am sparing you the Java to Kotlin conversions. This toy app lets you tap on the 8 ball for a message. It uses Otto Bus to notify the 8 Ball that a new message is needed as well as when a new message is available. How to tackle the migration - step by step Here are the basic steps for this kind of migration: Pick one event Find All the producers of this event (hopefully, there is only one but don't count on it) Replace with compatible functionality. We'll look at how to choose compatible functionality in the next section. Things will be broken. Find all subscribers of this event by looking for @Subscribe annotations. Replace with a matching access mechanism. Things should work at this point. Test that everything that used this one event still works Repeat with the next event until there are no events left to migrate Remove the Otto bus and it's dependencies Celebrate! Of course this looks deceptively simple. As simple as it is to add otto bus to a code ba ## This Week at Zed Industries: #10 DevFeed: [This Week at Zed Industries: #10]() Original publisher: [Read original article]() Author: Julia Risley Published: 2023-07-07T00:00:00Z Content type: article Language: en Sources: [Zed Industries - Blog]() Topics: [ui](), [Code](), [TypeScript](), [Rust](), [bug](), [Database](), [Network](), [macOS](), [Vim]() Tags: [bug](), [code](), [collaboration](), [crash](), [database](), [incremental](), [macos](), [network](), [refactor](), [rust](), [typescript](), [ui](), [vim]() ### AI overview A weekly Zed development update covering collaboration UI and native calling, theme code work, assistant fixes, GPUI and Vim improvements, and a macOS crash fix for multiple instances competing for local database access. ### Source excerpt A quiet week of rest and incremental improvement. ## I know Nothing in Kotlin DevFeed: [I know Nothing in Kotlin]() Original publisher: [Read original article]() Author: Colin Lee Published: 2022-09-16T15:32:41Z Content type: tutorial Language: en Sources: [Making Meetup - Medium]() Topics: [Kotlin](), [Exception](), [multiplatform](), [Coroutines](), [iOS](), [Swift]() Tags: [coroutines](), [dns](), [exception](), [exception-handling](), [ios](), [kotlin](), [kotlin-multiplatform-mobile](), [network](), [nothing](), [refactor](), [swift](), [timeout]() ### AI overview This article explains Kotlin's Nothing type through a code-pairing example involving repository calls in a shared Kotlin Multiplatform Mobile module. It describes refactoring repeated exception handling, rethrowing CancellationExceptions for cooperative coroutine cancellation, and using Nothing for functions that always throw. ### Source excerpt When the Greek philosopher Socrates professed that "I know only one thing -- that I know nothing," he wasn't exactly professing ignorance. It was an ancient formulation of the Dunning-Kruger effect. He had discovered that the more he learned, the wider the expanse of human knowledge seemed and the less that it seemed he knew. A fool, on the other hand, might believe that they're "not smart, but genius... and a very stable genius at that," and that they know "only the best words." In this sense, it's a good thing to know nothing. It's also true in Kotlin. During a recent code pairing session, I discovered that in Kotlin, there are numerous developers who have written code in the language for many years. And yet, they still don't know Nothing. Our pairing session became a big fuss about Nothing. We were working on some Repository code in our shared Kotlin Multiplatform Mobile (KMM) module of our Meetup for Organizers app. In this code, there was a repeated block at the end of every repository call to handle network, DNS, and timeout errors. We decided it would make sense to refactor this block into a function as we used it so often. The repeated block in question handled a catch block. It had to re-throw any CancellationExceptions to allow cooperative cancellation of coroutines. Then we had to wrap any other exception and re-throw it as a custom exception type so that we can easily tell iOS a complete list of all types we intend to throw in a @Throws declaration. This allows exception handling and avoids crashing when our functions are called by Swift code. In essence, this code block always threw an Exception. The pairing session became quite funny, like the Laurel and Hardy "Who's on First" comedy routine, but you could tell there was Nothing more frustrating, too. It went something like this: "Why am I getting this red text at the call site?" "The return type is incorrect because you always throw an exception. You need to return Nothing." "I already am returning nothi ## I Know Nothing in Kotlin DevFeed: [I Know Nothing in Kotlin]() Original publisher: [Read original article]() Published: 2022-08-30T17:52:35Z Content type: tutorial Language: en Sources: [Colin The Shots]() Topics: [Kotlin](), [Exception](), [Coroutines](), [kotlin multiplatform mobile]() Tags: [coroutines](), [exception-handling](), [kotlin](), [kotlin-multiplatform-mobile](), [refactor]() ### AI overview This developer article explains Kotlin's Nothing type through a refactoring example involving exception handling in a shared Kotlin Multiplatform Mobile repository. It distinguishes Nothing from Unit and describes using it when a function always throws, including when interoperating with Swift code and preserving coroutine cancellation. ### Source excerpt When the Greek philosopher Socrates professed that "I know only one thing-- that I know nothing," he wasn't exactly professing ignorance. It was an ancient formulation of the Dunning-Kruger effect. [Next page]()