# Stories by Gabor Varadi on Medium Stories by Gabor Varadi on Medium This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## Reclaim the reactivity of your state management, say no to imperative MVI DevFeed: [Reclaim the reactivity of your state management, say no to imperative MVI]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2022-05-02T05:05:46Z Content type: opinion Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [reactive](), [Redux](), [Elm](), [JavaScript](), [Programming]() Tags: [android](), [android-app-development](), [androiddev](), [architecture](), [architecture-pattern](), [clean-code](), [elm](), [javascript](), [model-view-intent](), [mvi](), [reactive](), [redux](), [state](), [state-management]() ### AI overview The article critiques imperative MVI-style state management as overly complex and boilerplate-heavy. It traces MVI's web-oriented history through Cycle.js, The Elm Architecture, and Redux, and questions whether those patterns fit statically typed application development. ### Source excerpt Do you find yourself chasing for "clean code, clean architecture, clean design, clean state management" yet still feel bogged down in a sea of boilerplate for even the simplest of tasks -- such as showing a simple list fetched with a coroutine? Surely this could be done in a single line or maybe about seven, but it certainly shouldn't need gigantic case-whens, three layers of indirection, and so on? Well, normally you could just invoke functions on ViewModel and it would work, but if you're forced to seek the "architectural holy grail", no one around you will trust your code unless you add at least one sealed class called ViewActions, and increase the cyclomatic complexity of your "action handler" function until it feels "just clean enough". (After all, surely the more completely unrelated things a single function does based on its argument, the more it has a "single responsibility" of handling literally everything, which is why you know it's definitely the best possible way to do it. 😏) Anyway, the boilerplate of coupling together all aspects into a single class, whether it is a function call or state property, this all has a history: namely, it came from the web. The brief history of MVI MVI stands for "model-view-intent" and comes from a (not very popular for use in production) Javascript framework called Cycle.js, hand-in-hand with a (not popular anymore) concept called "The Elm Architecture" defined as the best practices and intended use of an experimental (and since 2019, unmaintained) "functional-reactive programming language for the web" called ELM. Then again, these didn't come from a vacuum either -- the originator is Redux, in 2015. The general idea was to implement a state machine using the command processor pattern in Javascript, thereby supporting "undo" functionality (also often referred to as "time-travel debugging"). Of course, most design decisions of Redux only make sense for Javascript -- as it is a language with no static typing. It makes sense to ## Simplified navigation between Composables of Jetpack Compose using Simple-Stack DevFeed: [Simplified navigation between Composables of Jetpack Compose using Simple-Stack]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2021-03-09T15:10:09Z Content type: tutorial Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [Compose](), [Jetpack Compose](), [navigation](), [implementation]() Tags: [android-jetpack-compose](), [compose](), [gradle](), [jetpack-compose](), [lifecycle](), [navigation](), [persistence](), [simple-stack](), [state](), [state-management]() ### AI overview This tutorial explains how to use Simple-Stack's Compose integration for navigation between Jetpack Compose screens. It covers dependency and Activity setup, key classes, backstack navigation, configuration-change data storage, scoped services, lifecycle callbacks, and state persistence. The integration is described as beta. ### Source excerpt Have you ever wanted to navigate between two Composables? Do you wish it were as easy as backstack.goTo(SomeScreen(arg1, arg2)) and you would go there? Good news, because now that seems to be possible with Simple-Stack's Compose integration -- which I consider BETA for now, but nonetheless, it's possible. What it looks likeInitial setup and dependencies: First, you would add the dependencies: implementation 'com.github.Zhuinden:simple-stack:2.6.0' implementation 'com.github.Zhuinden:simple-stack-extensions:2.2.0' implementation 'com.github.Zhuinden:simple-stack-compose-integration:0.2.0' And of course, you'd add Jitpack (not JCenter): // build.gradle allprojects { repositories { // ... maven { url "https://jitpack.io" } } // ... } And most importantly, you'd enable Compose: compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } kotlinOptions { jvmTarget = '1.8' useIR = true } buildFeatures { compose true }Setup To use Simple-Stack within an Activity, we use the Navigator, as always. The Compose integration is merely a different implementation of StateChanger, along with a helper that allows exposing the Backstack as a CompositionLocal for children within the composable tree. class MainActivity : AppCompatActivity() { private val composeStateChanger = AnimatingComposeStateChanger() override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val backstack = Navigator.configure() .setScopedServices(DefaultServiceProvider()) .setStateChanger(AsyncStateChanger(composeStateChanger)) .install(this, androidContentFrame, History.of(FirstKey())) setContent { BackstackProvider(backstack) { MaterialTheme { Box(Modifier.fillMaxSize()) { composeStateChanger.RenderScreen() } } } } } override fun onBackPressed() { if (!Navigator.onBackPressed(this)) { super.onBackPressed() } } } This implementation of StateChanger is able to switch between keys that extend from DefaultComposeKey. In the samples, I genera ## Creating a BottomNavigation Multi-Stack using Child Fragments with Jetpack Navigation DevFeed: [Creating a BottomNavigation Multi-Stack using Child Fragments with Jetpack Navigation]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2021-02-26T06:14:32Z Content type: tutorial Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [Jetpack](), [navigation](), [Framework]() Tags: [android-app-development](), [androiddev](), [bottom-navigation](), [bottomnavigationview](), [jetpack](), [jetpack-navigation](), [lifecycle](), [navigation](), [navigation-component](), [screen](), [state]() ### AI overview This tutorial explains how to implement bottom navigation with a separate Jetpack Navigation NavController and back stack for each tab. It uses child fragments, adding all tab fragments while detaching those that are not visible, and initializes each tab with its own navigation graph. ### Source excerpt It's been a recurring question, regardless of navigation framework of choice: how is it possible to create a screen with a bottom navigation view, that would host a navigation history stack per each tab? Each framework has its own unique ways. For example, with Jetpack Navigation you might use the NavigationExtensions, which requires you to host the BottomNavigationView at the Activity-level. But how would you do it with Jetpack Navigation, in such a way that the BottomNavigationView is confined to a single child fragment, and that child fragment would host all tabs that each have a NavController (backstack) available to them? How bottom navigation with child fragments normally works If you intend to create a BottomNavigationView that is hosted by a Fragment (and that Fragment hosts each tab as a child fragment), there's a bit of work needed to be done. To keep the fragments alive while switching between them, they must all be added. However, to make sure that the fragments are in the correct lifecycle (stopped while not showing), it makes sense to detach them (and attach the one that is meant to be showing). https://medium.com/media/82eb957284cfe5def31160ac33d277ba/href This example is also available here. Please note that there is nothing specific to Jetpack Navigation in this snippet, this is how a fragment can manage its child fragments and keep only one of them attached, while the rest are detached. We will use this knowledge later in the article. What Jetpack Navigation normally does When you use Jetpack Navigation (using its XML-based DSL) you typically create a navigation.xml (typically 1 per compilation module, but multiple nav graphs + include can be used too), which is then given to a NavHostFragment in a FragmentContainerView. This is what allows the NavController to be initialized with a graph, and save/restore its state. https://medium.com/media/4cc60fc3c96786f7f9adcbb3a1053853/hrefCreating a NavController and backstack for each bottom navigation tab T ## An opinionated guide on how to make your Kotlin code fun to read and joy to work with DevFeed: [An opinionated guide on how to make your Kotlin code fun to read and joy to work with]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2021-02-15T06:16:05Z Content type: tutorial Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [Kotlin](), [Code]() Tags: [android](), [android-app-development](), [androiddev](), [code](), [code-style](), [guide](), [how-to](), [kotlin](), [maintainability](), [readability]() ### AI overview An opinionated guide to writing Kotlin code that is easier to read and maintain. It recommends formatting multi-argument constructors across lines, using let mainly in assignments or return statements, avoiding it for general control flow or side effects, and replacing implicit lambda arguments with meaningful names in complex expressions. ### Source excerpt I've been meaning to write this article in a while. Hopefully, the following tips and style recommendations (in no particular order) will help you write better Kotlin! Let's get on with it, shall we? For 2 or more constructor arguments, prefer not to keep the properties on the same line as the class name in the constructor definitionclass MyClass( val a: A, val b: B, ): MyParentClass(a, b), MyInterface { // ... } This format is preferable, because when adding the 3rd argument, important bits (such as a possible base class or interface) can appear too far on the right side of the screen. Listing them one after the other (including the trailing comma since 1.4.21+) allows for better readability and extensibility (reducing the chance of causing merge conflicts with future code changes, for example). Prefer to use the scoping function 'let' only in assignments or return statements, but NOT as general control flow, or a "quick rename to 'it'" Oftentimes, Kotlin code tends to do something like this: fun myMethod(nullableA: A?) { nullableA?.let { // no it.x() // no it.y() // no it.z() // no } } (Note: in a method like this, A? could be replaced with A to take advantage of typed nullability, this is just an example.) To allow better maintainability and readability, we should instead prefer to only use ?.let { in simple assignments, or return statements, but not as general control flow. For example, the following chain is easy to understand: val protoClass = savedInstanceState?.getByteArray("protoValue") ?.let { ProtoClass.parseFrom(it) } However, in this case, ?.let { is part of an assignment. Also, while ?.let { can be chained with a ?: to provide a default value (especially in combination with takeIf) it shouldn't be used to execute side-effects (also is more suitable for that). In fact, it needs to be said: x?.let {} ?: run {} is NOT a general purpose replacement for if-else statements and null-checks, and should never be used in this particular format for that purpose! ## Dagger Tips: Guide to using Dagger-Android effectively DevFeed: [Dagger Tips: Guide to using Dagger-Android effectively]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2021-02-13T05:05:50Z Content type: tutorial Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [Dagger](), [Android](), [Architecture & Design](), [Development](), [Scalability]() Tags: [android](), [dagger](), [dagger-2](), [dagger-android](), [dependency-injection](), [development](), [guide](), [interface](), [modularization](), [module](), [scalability]() ### AI overview A guide to using Dagger-Android, explaining its field-injection approach, the modularization constraints it addresses, and alternatives involving interfaces or shared superclasses. The article notes that Dagger-Android has been superseded by Hilt for common injection cases. ### Source excerpt Something people could ask me as they're reading this title: "Hold on a second, isn't Dagger-Android no longer in active development? Isn't it made obsolete with the introduction of Hilt?" Technically, yes. Dagger-Android is superseded by Hilt. So there is a good chance that if you are already using Hilt, then for the most common cases (injecting Activity, Fragment, ViewModel, Worker), you don't need to think about Dagger-Android whatsoever. However, as I still see @ContributesAndroidInjector popping up every now and then, I feel that it's best if I write an article on how it works, what it intended to solve, how to use it, and how NOT to use it (for better scalability). What was Dagger-Android? Dagger-Android was a way to field-inject classes (not necessarily just Android classes since Dagger 2.20+) without having to define a fun inject(target: MyConcreteClassTarget) injector method on the component -- as we don't know the class itself. When do you want to avoid creating fun inject(t: T) in a component? After all, this is what normally allows field injection to be type-safe. The answer is, when you can't. If you use a modularization pattern where :app contains the ApplicationComponent(or SingletonComponent), then while ApplicationComponent can see any Activity or Fragment within the app, the submodules don't see :app and therefore don't see ApplicationComponent. Therefore, they can't call component.inject(this)! On the other hand, if you were to define an Application.ActivityLifecycleCallbacks to do it automatically, that wouldn't work with the standard approach -- as you see only the superclass, but not the concrete class! So if one wants to use field injection with our provided restrictions, there are two options: Expose an interface from the child module that defines the injection targets, and implement that on the ApplicationComponent -- then make it possible to access it (for example, using the ApplicationContext for lookup) and cast it to the interface to be abl ## Creating a BottomNavigation Multi-Stack using child Fragments with Simple-Stack DevFeed: [Creating a BottomNavigation Multi-Stack using child Fragments with Simple-Stack]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2021-01-25T17:03:22Z Content type: tutorial Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [navigation](), [Jetpack](), [configuration]() Tags: [android-app-development](), [bottom-navigation](), [bottomnavigationview](), [configuration](), [fragments](), [jetpack](), [jetpack-navigation](), [navigation](), [simple-stack]() ### AI overview A tutorial on implementing bottom navigation with a separate navigation history stack for each tab using child fragments and Simple-Stack. It explains fragment attachment and detachment, lifecycle management, and keeping back stacks alive across configuration changes. ### Source excerpt It's been a recurring question, regardless of navigation framework of choice: how is it possible to create a screen with a bottom navigation view, that would host a navigation history stack per each tab? Each framework has its own unique ways. For example, Jetpack Navigation provides NavigationExtensions as a sample, there's FragNav, but how would you do it with Simple-Stack? How bottom navigation with child fragments normally works If you intend to create a BottomNavigationView that is hosted by a Fragment (and that Fragment hosts each tab as a child fragment), there's a bit of work needed to be done. To keep the fragments alive while switching between them, they must all be added. However, to make sure that the fragments are in the correct lifecycle (stopped while not showing), it makes sense to detach them (and attach the one that is meant to be showing). https://medium.com/media/1667d9733c198c3ae611fd45504f6bd0/href This example is also available here. Please note that there is nothing specific to Simple-Stack in this snippet, this is how a fragment can manage its child fragments and keep only one of them attached, while the rest are detached. In fact, the NavigationAdvancedSample works the same way. We will use this knowledge later in the article. What Simple-Stack normally does When you use Simple-Stack, you typically install a Navigator using Navigator.install(). This allows a single global Backstack instance to be accessible through the Activity's context (and thus making it available to all views within the Activity), and provides automatic lifecycle management to ensure that navigation is handled correctly. https://medium.com/media/03bde713eca4e7ef47d7dae31f6e095d/href This is important to know, because if we want to create a Backstack for each Fragment within our BottomNavigationView, we must manage the lifecycle (and keep the Backstack instance alive across configuration changes) ourselves. Thankfully, this is actually quite simple to do! After all, frag ## An update to the FragmentViewBindingDelegate: the bug we've inherited from AutoClearedValue DevFeed: [An update to the FragmentViewBindingDelegate: the bug we've inherited from AutoClearedValue]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2021-01-24T00:40:53Z Content type: article Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [Jetpack](), [bug](), [navigation]() Tags: [android-app-development](), [android-view-binding](), [bottom-navigation](), [bug](), [fragments](), [jetpack](), [jetpack-lifecycle](), [kotlin](), [navigation]() ### AI overview The article identifies a bug in an AutoClearedValue-based FragmentViewBindingDelegate. A fragment can move directly from view creation to view destruction without becoming active, so the observer never runs and the binding is not cleared. The proposed fix is to observe the view lifecycle without using the fragment as the lifecycle owner. ### Source excerpt Jetpack Lifecycle is quite powerful. We can extract logic, and make it lifecycle-aware. In fact, this allowed us in a previous article to simplify viewbinding and make it a single line. However, I need to provide a quick heads-up: all is not as it seems. The provided gists and code snippets assumed that the code in AutoClearedValue is always correct. In this article, I'll show you how to break it. The original sourcehttps://medium.com/media/74ef2eaf8bac6a656cece1f95796034a/href The general idea behind AutoClearedValue is that a value hidden by this delegate would only be created when it is set (in our case, when it is accessed), and when viewLifecycleOwner becomes DESTROYED, it would null out the value. Makes sense, right? In order to access the view lifecycle, the code waits until Fragment.onCreate(), and registers the lifecycle observer there. Then, using the fragment as the lifecycle owner (!), it attempts to register a lifecycle observer on the view lifecycle owner. The bug hiding in plain sight The problem is that it is possible for the view lifecycle to be initialized in such a way that fragment.onStart() and therefore viewLifecycleOwner.lifecycle.addObserver never actually happens. The fragment goes directly from onViewCreated to onDestroyView. Meaning, fragment.onStart() and fragment.onStop() never happen. This means that fragment.viewLifecycleOwner.observe(fragment) will NEVER be ACTIVE, and therefore the observe block will never be called. The viewLifecycle reaches DESTROYED without it being observed. When does this happen? If a fragment is added with commitNow(), but then is detach()ed. This would mean that this could happen with FragmentPagerAdapter, as that also uses attach/detach under the hood. In my case, the bug surfaced when using the binding along with the following construct: https://medium.com/media/942d1d2a1b2b4bbdc77e4d11ef112b97/href In case of a bottom navigation view, where fragments were added but attached/detached, the view in the binding ## Structural and navigation anti-patterns in modularized Android applications DevFeed: [Structural and navigation anti-patterns in modularized Android applications]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2020-12-25T11:38:05Z Content type: article Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [Android](), [Gradle](), [modules](), [navigation](), [Code](), [Dagger](), [Dependency injection](), [RxJava]() Tags: [android](), [android-app-development](), [antipattern](), [architecture](), [clean-architecture](), [code](), [dagger](), [dagger-2](), [dependency-injection](), [domain-driven-design](), [gradle](), [modularization](), [modules](), [navigation](), [navigation-architecture](), [rxjava]() ### AI overview This article examines structural and navigation anti-patterns in modularized Android applications. It traces the history of Android Clean Architecture and argues that organizing an application around top-level data, domain, and presentation modules can be problematic, particularly when the structure is adopted from educational examples rather than feature-based organization. ### Source excerpt Structural and navigation anti-patterns in multi-module and modularized applications: The case against "Android Clean Architecture" and the "domain" moduleTop-level "domain" module is a code smell. Merry Christmas to all! The subject of this article is one that has been on my mind for a very long time. After all, "Clean Architecture" is often seen as the end goal, the hallmark of the finest of Android application code structure -- it is the best of the very best. The name itself, "Clean Architecture", signals that it's a good thing ~ after all, who wants to work with "messy" code in comparison? Of course, the title of this article shows that this isn't the conclusion we'll come to. The following tweet is closer to our final evaluation -- let us analyze why it might be accurate. Clean architecture + Android for us was like building a beautiful sailing boat in your backyard because someone on TV convinced you it's better for crossing the sea than an inflatable, while you live in the mountains and also your house is on fire. https://t.co/iGqy25wk7m The history of "Android Clean Architecture"The origins To understand "Clean Architecture" as done on Android, we must trace it back to its roots, and where/when it was made popular in the first place. As far as I'm aware, it dates back to 2014, the original proposition in "Fernando Cejas: Architecting Android... the clean way?". It was a highly influential article, as it revolutionized the structure of Android apps. Code that is actually separated across layers (back when Fragments were untrustworthy, and all code was in OS-level components), rather than just throwing everything into 2000+ line Activities? A pioneer of its time. One interesting decision however in the representative sample code was that in order to signify the strict separation of layers, these layers were each separated from one another using top-level Gradle modules, each labeled data, domain, and presentation. As we will see, this is the downfall of the sampl ## Simplified Android Development Using Simple-Stack DevFeed: [Simplified Android Development Using Simple-Stack]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2020-11-14T03:32:51Z Content type: tutorial Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [navigation](), [android-development](), [Android](), [Framework](), [android-apps]() Tags: [android](), [android-app-development](), [android-apps](), [android-development](), [androiddev](), [dagger-hilt](), [fragments](), [jetpack](), [navigation](), [simple-stack]() ### AI overview An Android development article explains Simple-Stack, a navigation framework for tracking navigation state with immutable Parcelable screen identifiers. It describes the framework's origins in Flow and Mortar and its use for type-safe Fragment navigation. ### Source excerpt It's been a long time since I've wanted to write this article. Time to go at it, shall we? :) People always seem to be surprised and say, "wait, you DON'T use Jetpack ViewModel, Jetpack Navigation, and Dagger-Hilt? Then what DO you use?" This article intends to answer that. We use Simple-Stack. (If you prefer watching talks, then a talk on the same subject is available at https://www.youtube.com/watch?v=5ACcin1Z2HQ) What is Simple-Stack? Simple-Stack is a navigation framework that I've been working on since the beginning of 2017, although its roots go back to 2015 -- when we were still experimenting with multiple versions of Mortar & Flow. (The 90s kids might still remember). Following up on the original proposition by Square, "Advocating Against Android Fragments" and "Simpler Android Apps with Flow and Mortar", we've been using Single-Activity approach in our apps since 2015. Now, the history of Flow and Mortar isn't all roses. I've heard people say "we tried it and it didn't work for us". I can attest to that: we had to manage our own fork, but even with that, we hit some of its limitations over time. We needed something reliable and versioned, so we rewrote Flow's original behavior, and intended to improve upon its limitations. This rewrite is what resulted in the creation of Simple-Stack. Why Simple-Stack? Simple-Stack is based on the idea that you intend to track your navigation state as a list of immutable and Parcelable classes -- screen identifiers (which the library calls "keys"). As long as the underlying navigation implementation allows for "navigation from any state to any state", it is possible to wrap that implementation using Simple-Stack. For example, something I hear often is that "navigation with Fragments is hard". I always point out that in our code, it's been like this since 2016: backstack.goTo(new SecondScreen(detailId)); // java No explicit fragment transaction, no Bundle, no newInstance(), just calling a method. How is this possible? Isn't Fr ## Building Reactive UIs with LiveData and SavedStateHandle (or equivalent approaches) DevFeed: [Building Reactive UIs with LiveData and SavedStateHandle (or equivalent approaches)]() Original publisher: [Read original article]() Author: Gabor Varadi Published: 2020-10-04T19:53:05Z Content type: tutorial Language: en Sources: [Stories by Gabor Varadi on Medium]() Topics: [reactive](), [Android](), [Jetpack](), [RxJava]() Tags: [android](), [android-app-development](), [coroutine](), [jetpack](), [lifecycle](), [livedata](), [observable](), [reactive](), [reactive-programming](), [room](), [rxjava](), [savedstatehandle]() ### AI overview This article explains LiveData as a reactive, observable, lifecycle-aware data holder for Android applications. It argues that LiveData remains useful alongside RxJava and Kotlin coroutines because its lifecycle activation states allow it to represent reactive data sources, including Room-backed data that refreshes after invalidation. ### Source excerpt Building Reactive UIs with LiveData and SavedStateHandle (or equivalent approaches like Rx) You can also follow the related discussion thread on /r/android_devs. LiveData is a misunderstood beast. Every so often, you see comments like "LiveData does not belong in Repositories", or that with the existence of RxJava, Coroutine Channels, or Coroutine Flows -- there's "no reason to use LiveData at all". While there are components in these libraries that have overlapping responsibilities (BehaviorRelay, ConflatedBroadcastChannel, MutableStateFlow), that doesn't mean LiveData is useless. With the relatively new additions to Jetpack, such as the liveData { coroutine builder, LiveData is actually quite interesting. What is LiveData? If you try to find a definition for LiveData, you'll find that it's a "reactive, observable, lifecycle-aware data holder". We know it can be observed, and we know it holds 1 data value that is re-emitted for any new observer (and any changes made to it are also emitted), just like any BehaviorRelay. But what makes it special? Due to LiveData's lifecycle-awareness, it comes with its own "activation state" ( onActive and onInactive). It lets you know when there is an active observer, and when there are no longer any active observers. The trick is that this makes it far more than "just an every-day data holder". This allows LiveData to represent reactive datasources. I'd even wager that this is the original purpose for which LiveData was created, if Room's ComputableLiveData is any indication (as that also relies on onActive to trigger the refresh of the query results, if the table had been invalidated by a write to it). Why do I want reactive datasources? If you have data or state that can change over time, it's significantly easier to be notified of changes, than it is to poll for possible changes (and potentially miss out on changes if we tried to fetch data at the wrong time). This means that by using an "observer" (or change listener), we can r