Bank of America Securities analyst Jessica Reif Cohen has reiterated their neutral stance on CHTR stock, giving a Hold rating today. Jessica Reif Cohen’s Hold rating for Charter Communications is grounded on a blend of factors. Firstly, Charter’s third ...

Charter Communications: Balancing Increased Capex, Rural Market Expansion and Subscriber Growth Amidst Competitive Pressure

Brenda Reif-Ranger of Eldred was selected as the winner of the second round of a photography contest run by Rep C.D. Davidsmeyer, R-Murrayville. The contest invites people to submit photos taken in the 100th District, which he represents.

Greene woman wins second round of Davidsmeyer photo contest

"I was very neglectful. And that will not happen again. And I tell everybody now, go get checked, mama was faithful," said Freda.

Oklahoma mother and daughter beat breast cancer by getting regular mammograms

State Representative C.D. Davidsmeyer (R-Murrayville) today announced the winning photograph in the second round of his 2023 photo contest.

Rep. Davidsmeyer announces Photo Contest Winner in Second Round of Submissions for 2023

If you want the most affordable Audi SUV, you won't find it in the 2023 Audi Q5. But, it's still the model that's selling the best in the Audi lineup. Read on for more.

The Most Popular Audi Isn’t the Cheapest Audi in 2023

Here's a look at how much a fully loaded 2024 Ram 3500 heavy-duty pickup truck model costs, factoring in trim levels, accessories, add-ons, and more.

How Much Does a Fully Loaded 2024 Ram 3500 Cost?

BENNINGTON — Faced with filling the unexpected opening of a new athletic director after Paul Reif’s resignation earlier this month, the Mount Anthony school board looked for a familiar face. It got exactly that with Mike Molloy, who was unanimously elected to fill the role on an interim basis during Wednesday’s special school board meeting.

Former Mount Anthony soccer coach Mike Molloy takes the reins as interim athletic director

Bank of America analyst Jessica Reif Ehrlich said the company's language surrounding streaming profitability and how quickly it can cut costs will be an important earnings focus this quarter.

Disney has 'a lot of work' to do but one analyst still sees 'some optimism' ahead

Analysts agree it's undervalued, but majority owner Silver Lake believes going private is a better way to bump up the agency-turned-lifestyle company The post What’s Behind Endeavor’s Plan to Go Private,

What’s Behind Endeavor’s Plan to Go Private, Sell Assets

Israeli forces backed by fighter jets and drones have carried out a second ground raid into Gaza in as many days. The military said Friday that it struck targets on

Israel strikes the outskirts of Gaza City during a second ground raid in as many days

Reif

reif

The HackerNoon Newsletter: Refactoring 019 - How to Reify Email Addresses (12/5/2024)

Say it once and only once TL;DR: Avoid duplicate email validations. Problems Addressed Repeated email validation logic in multiple places.
Risk of inconsistent validation rules.
Bijection violation
Primitive Obsession
Premature Optimization Related Code Smells https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-x-i7r34uj https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi Code Smell 20 - Premature Optimization Steps Identify where email validation logic is duplicated.


Create an Email Address class to encapsulate validation rules.


Refactor code to use the Email Address class instead of raw strings. Sample Code Before public class Person {
    private String emailAddress;
    // Primitive Obsession

    public void setEmailAddress(String emailAddress) {
        // Duplicated code
        if (!emailAddress.matches(
            "^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.emailAddress = emailAddress;
    }
}

public class JobApplication {
    private String applicantEmailAddress;

    public void setApplicantEmailAddress(String emailAddress) {
        // Duplicated code
        if (!emailAddress.matches(
            "^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.applicantEmailAddress = emailAddress;
    }
} After public class EmailAddress {
    // 2. Create an `EmailAddress` class to encapsulate validation rules.
    private final String value;

    public EmailAddress(String value) {
        // The rules are in a single place
        // And all objects are created valid
        if (!value.matches("^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.value = value;
    }
}

public class Person {
    private final EmailAddress emailAddress;

    public Person(EmailAddress emailAddress) {
        // 1. Identify where email validation logic is duplicated.
        // 3. Refactor code to use the `Email Address`
        // class instead of raw strings.
        // No validation is required
        this.emailAddress = emailAddress;
    } 
}

public class JobApplication {
    private EmailAddress applicantEmailAddress;

    public JobApplication(EmailAddress applicantEmailAddress) {
        this.applicantEmailAddress = applicantEmailAddress;
    }
} Type [x]Semi-Automatic Safety This refactoring is safe if you replace all occurrences of raw email strings with the 'EmailAddress' class and ensure all tests pass. Why Is the Code Better? You make email validation consistent across your application. Since validation rules are centralized in one place, the code becomes easier to maintain. You also reduce the risk of bugs caused by inconsistent logic. In the real world, Email Addresses are small objects that exist and are not strings. The refactored code is closer to the real-world MAPPER. Notice that bijection names are essential. It would help to create an EmailAddress, not an Email, since the Email should map to the actual message. Don't let Premature Optimizators tell you this solution has a performance penalty. They never do actual benchmarks with real-world data. Refactor With AI Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini Tags Encapsulation Related Refactorings https://maximilianocontieri.com/refactoring-007-extract-class?embedable=true https://maximilianocontieri.com/refactoring-012-reify-associative-arrays?embedable=true https://hackernoon.com/improving-the-code-one-line-at-a-time?embedable=true Credits Image by Gerd Altmann on Pixabay This article is part of the Refactoring Series. How to Improve Your Code With Easy Refactorings Say it once and only once Say it once and only once TL;DR: Avoid duplicate email validations. TL;DR: Avoid duplicate email validations. Problems Addressed Repeated email validation logic in multiple places. Risk of inconsistent validation rules. Bijection violation Primitive Obsession Premature Optimization Repeated email validation logic in multiple places. Repeated email validation Risk of inconsistent validation rules. Bijection violation Bijection Primitive Obsession Primitive Obsession Premature Optimization Premature Optimization Related Code Smells https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-x-i7r34uj https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-x-i7r34uj https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvi Code Smell 20 - Premature Optimization Code Smell 20 - Premature Optimization Steps Identify where email validation logic is duplicated. Create an Email Address class to encapsulate validation rules. Refactor code to use the Email Address class instead of raw strings. Identify where email validation logic is duplicated. Identify where email validation logic is duplicated. Create an Email Address class to encapsulate validation rules. Create an Email Address class to encapsulate validation rules. Email Address Refactor code to use the Email Address class instead of raw strings. Refactor code to use the Email Address class instead of raw strings. Email Address Sample Code Before public class Person {
    private String emailAddress;
    // Primitive Obsession

    public void setEmailAddress(String emailAddress) {
        // Duplicated code
        if (!emailAddress.matches(
            "^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.emailAddress = emailAddress;
    }
}

public class JobApplication {
    private String applicantEmailAddress;

    public void setApplicantEmailAddress(String emailAddress) {
        // Duplicated code
        if (!emailAddress.matches(
            "^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.applicantEmailAddress = emailAddress;
    }
} public class Person {
    private String emailAddress;
    // Primitive Obsession

    public void setEmailAddress(String emailAddress) {
        // Duplicated code
        if (!emailAddress.matches(
            "^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.emailAddress = emailAddress;
    }
}

public class JobApplication {
    private String applicantEmailAddress;

    public void setApplicantEmailAddress(String emailAddress) {
        // Duplicated code
        if (!emailAddress.matches(
            "^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.applicantEmailAddress = emailAddress;
    }
} After public class EmailAddress {
    // 2. Create an `EmailAddress` class to encapsulate validation rules.
    private final String value;

    public EmailAddress(String value) {
        // The rules are in a single place
        // And all objects are created valid
        if (!value.matches("^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.value = value;
    }
}

public class Person {
    private final EmailAddress emailAddress;

    public Person(EmailAddress emailAddress) {
        // 1. Identify where email validation logic is duplicated.
        // 3. Refactor code to use the `Email Address`
        // class instead of raw strings.
        // No validation is required
        this.emailAddress = emailAddress;
    } 
}

public class JobApplication {
    private EmailAddress applicantEmailAddress;

    public JobApplication(EmailAddress applicantEmailAddress) {
        this.applicantEmailAddress = applicantEmailAddress;
    }
} public class EmailAddress {
    // 2. Create an `EmailAddress` class to encapsulate validation rules.
    private final String value;

    public EmailAddress(String value) {
        // The rules are in a single place
        // And all objects are created valid
        if (!value.matches("^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException(
                "Invalid email address format");
        }
        this.value = value;
    }
}

public class Person {
    private final EmailAddress emailAddress;

    public Person(EmailAddress emailAddress) {
        // 1. Identify where email validation logic is duplicated.
        // 3. Refactor code to use the `Email Address`
        // class instead of raw strings.
        // No validation is required
        this.emailAddress = emailAddress;
    } 
}

public class JobApplication {
    private EmailAddress applicantEmailAddress;

    public JobApplication(EmailAddress applicantEmailAddress) {
        this.applicantEmailAddress = applicantEmailAddress;
    }
} Type [x]Semi-Automatic [x] Semi-Automatic [x] Safety This refactoring is safe if you replace all occurrences of raw email strings with the 'EmailAddress' class and ensure all tests pass. Why Is the Code Better? You make email validation consistent across your application. Since validation rules are centralized in one place, the code becomes easier to maintain. You also reduce the risk of bugs caused by inconsistent logic. In the real world, Email Addresses are small objects that exist and are not strings. Email Addresses small objects The refactored code is closer to the real-world MAPPER . MAPPER Notice that bijection names are essential. It would help to create an EmailAddress , not an Email , since the Email should map to the actual message. EmailAddress Email map Don't let Premature Optimizators tell you this solution has a performance penalty. Premature Optimizators They never do actual benchmarks with real-world data. Refactor With AI Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini Without Proper Instructions

With Specific Instructions ChatGPT

ChatGPT Claude

Claude Perplexity

Perplexity Copilot

Copilot Gemini

Gemini Without Proper Instructions With Specific Instructions Without Proper Instructions Without Proper Instructions With Specific Instructions With Specific Instructions ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT Claude Claude Claude Claude Claude Claude Claude Claude Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Copilot Copilot Copilot Copilot Copilot Copilot Copilot Copilot Gemini Gemini Gemini Gemini Gemini Gemini Gemini Gemini Tags Encapsulation Encapsulation Related Refactorings https://maximilianocontieri.com/refactoring-007-extract-class?embedable=true https://maximilianocontieri.com/refactoring-007-extract-class?embedable=true https://maximilianocontieri.com/refactoring-012-reify-associative-arrays?embedable=true https://maximilianocontieri.com/refactoring-012-reify-associative-arrays?embedable=true https://hackernoon.com/improving-the-code-one-line-at-a-time?embedable=true https://hackernoon.com/improving-the-code-one-line-at-a-time?embedable=true Credits Image by Gerd Altmann on Pixabay Gerd Altmann Pixabay This article is part of the Refactoring Series. How to Improve Your Code With Easy Refactorings How to Improve Your Code With Easy Refactorings

Refactoring 019 - How to Reify Email Addresses

إعادة الهيكلة 019 - كيفية إعادة هيكلة عناوين البريد الإلكتروني

রিফ্যাক্টরিং 019 - ইমেল ঠিকানাগুলিকে কীভাবে রিফাই করা যায়

Refactoring 019 - Sådan bekræftes e-mail-adresser

Refactorización 019: Cómo reificar direcciones de correo electrónico

Refactoring 019 - כיצד לאמת כתובות דוא"ל

Refactoring 019 - Ինչպես վերականգնել էլփոստի հասցեները

リファクタリング 019 - メールアドレスを具体化する方法

Refactoring 019 - របៀបកែតម្រូវអាសយដ្ឋានអ៊ីមែល

Refactoring 019 - ວິທີການ Reify ທີ່ຢູ່ອີເມວ

Refactoring 019 - Tsela ya go Reify Diaterese tša Imeile

Refactoring 019 - Si të rivendosni adresat e postës elektronike

Refactoring 019 - Paano Reify ang Mga Email Address

Ethereum Is More Than Crypto. It’s a Machine for Making Worlds

Navigation in Compose is all about making your app's flow feel natural and effortless – no more juggling a bunch of XML files or wrestling with clunky code. In this article, I'll explain how Jetpack Compose handles navigation between screens with a modern, declarative twist. You'll learn how to set up a NavController and a NavHost to create clear, maintainable navigation paths, pass data between screens, and handle transitions with ease. Whether you're building a multi-screen app or just trying to keep your UI organized, Compose's navigation component lets you map out your app's journey using simple, intuitive code. It's like drawing a roadmap for your app, but without the headache. Android Jetpack's Navigation component includes the Navigation library, Safe Args Gradle plug-in, and tooling to help you implement app navigation. The Navigation component handles diverse navigation use cases – from straightforward button clicks to more complex patterns such as app bars and navigation drawers. Navigation library Navigation library Safe Args Gradle plug-in Safe Args Gradle plug-in If you want to fully migrate your app to Compose and use Navigation Compose, there are a few concepts you need to know to get started: NavController In Jetpack Compose, the NavController is a central component responsible for managing navigation within an app. It is part of the Navigation component, which enables you to navigate between different destinations (screens or composables) in your app, manage the back stack, and pass data between destinations. The NavController is used to trigger navigation actions – such as moving forward or backward – and to manage the state of the navigation stack, allowing the app to handle features like deep linking, back navigation, and passing arguments to destinations. NavController NavHost In Jetpack Compose, NavHost is a key component for setting up navigation within your app. It serves as the container where your composable screens (destinations) are displayed and managed. Essentially, it links the navigation graph (which defines all the possible routes and their relationships) with the UI elements that users interact with. NavGraph NavGraph In Jetpack Compose, a NavGraph (short for Navigation Graph) is a logical container that defines the set of destinations (screens or composables) and the relationships between them. It is used in conjunction with NavHost to manage the flow of navigation within an app. A NavGraph represents the complete navigation structure of your app and helps define how users can move from one screen (destination) to another. It holds all the routes (destinations) that can be navigated to, along with their associated arguments or deep links. While NavHost is the UI component that renders the screens based on the navigation state, the NavGraph focuses on defining and organizing the available routes. Example @Composable
fun MyApp() {
  val navController = rememberNavController()

  NavHost(navController = navController, startDestination = "home") {
    composable("home") { HomeScreen(navController) }
    composable("details/{id}") { backStackEntry ->
      DetailsScreen(id = backStackEntry.arguments?.getString("id"))
    }
  }
}

@Composable
fun HomeScreen(navController: NavController) {
  Column {
    Text("Home Screen")
    Button(onClick = { navController.navigate("details/1") }) {
      Text("Go to Details")
    }
  }
}

@Composable
fun DetailsScreen(id: String?) {
  Text("Details Screen, ID: $id")
} @Composable
fun MyApp() {
  val navController = rememberNavController()

  NavHost(navController = navController, startDestination = "home") {
    composable("home") { HomeScreen(navController) }
    composable("details/{id}") { backStackEntry ->
      DetailsScreen(id = backStackEntry.arguments?.getString("id"))
    }
  }
}

@Composable
fun HomeScreen(navController: NavController) {
  Column {
    Text("Home Screen")
    Button(onClick = { navController.navigate("details/1") }) {
      Text("Go to Details")
    }
  }
}

@Composable
fun DetailsScreen(id: String?) {
  Text("Details Screen, ID: $id")
} rememberNavController() – Creates and remembers a NavController instance for the current composable, ensuring its state is preserved across recompositions.
NavHost – Acts as the container where navigation occurs, defining the UI region for destination composables and specifying the start destination (e.g., startDestination = "home").
NavGraph – Within the NavHost, you declare individual destinations (such as composable("home") and composable("details/{id}")). This is where you define the navigation graph that outlines all possible navigation flows in your app. rememberNavController() – Creates and remembers a NavController instance for the current composable, ensuring its state is preserved across recompositions. rememberNavController() NavHost – Acts as the container where navigation occurs, defining the UI region for destination composables and specifying the start destination (e.g., startDestination = "home"). NavHost NavGraph – Within the NavHost, you declare individual destinations (such as composable("home") and composable("details/{id}")). This is where you define the navigation graph that outlines all possible navigation flows in your app. NavGraph Google’s approach Out of the box, Google suggests passing an ID for your data and storing it in a cache (in-memory, database, etc.). But what if your app doesn’t have any of these, yet you still want to migrate? In that case, there's a trick you can use. Instead of passing an ID, you can serialize the entire data class that you need to pass to the next screen, and then deserialize it when you navigate to the destination. To simplify the process, it's a good idea to add a couple of helper classes: NavigationDefines.kt NavigationDefines.kt NavigationDefines.kt const val NAVIGATION_DATA_ARGUMENT = “navigationData” const val NAVIGATION_DATA_ARGUMENT = “navigationData” ComposeNavGraphExtensions.kt ComposeNavGraphExtensions.kt ComposeNavGraphExtensions.kt inline fun <reified T : Parcelable> NavGraphBuilder.composableWithData(
  route: String,
  crossinline content: @Composable (T) -> Unit
) {
  composable(
    route = route,
    arguments = listOf(navArgument(NAVIGATION_DATA_ARGUMENT) { type = NavigationArgumentsNavType<T>() })
  ) {
    it.arguments?.parcelable(NAVIGATION_DATA_ARGUMENT, T::class.java)?.let {  inputData ->
      content(inputData)
    } ?: run {
      throw IllegalStateException("Cannot navigate to $route. Expected arguments - ${T::class.qualifiedName}, but the actual value is ${it.arguments}")
    }
  }
} inline fun <reified T : Parcelable> NavGraphBuilder.composableWithData(
  route: String,
  crossinline content: @Composable (T) -> Unit
) {
  composable(
    route = route,
    arguments = listOf(navArgument(NAVIGATION_DATA_ARGUMENT) { type = NavigationArgumentsNavType<T>() })
  ) {
    it.arguments?.parcelable(NAVIGATION_DATA_ARGUMENT, T::class.java)?.let {  inputData ->
      content(inputData)
    } ?: run {
      throw IllegalStateException("Cannot navigate to $route. Expected arguments - ${T::class.qualifiedName}, but the actual value is ${it.arguments}")
    }
  }
} ComposeNavHostExtensions.kt ComposeNavHostExtensions.kt ComposeNavHostExtensions.kt fun <T : Parcelable> NavHostController.navigateWithData(route: String, navigationArguments: T) {
  val routeString = navigationArguments.toRouteString()
  navigate("$route/$routeString")
} fun <T : Parcelable> NavHostController.navigateWithData(route: String, navigationArguments: T) {
  val routeString = navigationArguments.toRouteString()
  navigate("$route/$routeString")
} NavigationArgumentsNavType.kt NavigationArgumentsNavType.kt NavigationArgumentsNavType.kt data class NavigationArgumentsNavType<T : Parcelable>(private val type: Class<T>) : NavType<T>(isNullableAllowed = false) {

  companion object {
    inline operator fun <reified T : Parcelable> invoke(): NavigationArgumentsNavType<T> = NavigationArgumentsNavType(T::class.java)
  }

  override fun get(bundle: Bundle, key: String): T? = bundle.parcelable(key, type)
  override fun parseValue(value: String): T = fromRouteSting(value, type)
  override fun put(bundle: Bundle, key: String, value: T) = bundle.putParcelable(key, value)
} data class NavigationArgumentsNavType<T : Parcelable>(private val type: Class<T>) : NavType<T>(isNullableAllowed = false) {

  companion object {
    inline operator fun <reified T : Parcelable> invoke(): NavigationArgumentsNavType<T> = NavigationArgumentsNavType(T::class.java)
  }

  override fun get(bundle: Bundle, key: String): T? = bundle.parcelable(key, type)
  override fun parseValue(value: String): T = fromRouteSting(value, type)
  override fun put(bundle: Bundle, key: String, value: T) = bundle.putParcelable(key, value)
} ParcelableExtension.kt ParcelableExtension.kt ParcelableExtension.kt fun <T : Parcelable> Bundle.parcelable(key: String, type: Class<T>): T? = when {
  Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> getParcelable(key, type)
  else -> @Suppress("DEPRECATION") getParcelable(key) as T?
} fun <T : Parcelable> Bundle.parcelable(key: String, type: Class<T>): T? = when {
  Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> getParcelable(key, type)
  else -> @Suppress("DEPRECATION") getParcelable(key) as T?
} ParcelableSerializationUtils.kt ParcelableSerializationUtils.kt ParcelableSerializationUtils.kt private const val DELIMITER = "@"

fun <T : Parcelable> T.toRouteString(): String {
  return javaClass.name + DELIMITER + toBase64()
}

fun <T : Parcelable> fromRouteSting(routeString: String, type: Class<T>): T {
  val (className, base64) = routeString.split(DELIMITER).let { it[0] to it[1] }

  val creator = if (type.isFinal) {
    // Since we have this, small optimisation to avoid additional reflection call of Class.forName
    type.parcelableCreator
  } else {
    // If our class is not final, then we must use the actual class from "className"
    parcelableClassForName<T>(className).parcelableCreator
  }

  return base64ToParcelable(base64, creator)
}

private fun Parcelable.toBase64(): String {
  val parcel = Parcel.obtain()
  writeToParcel(parcel, 0)
  val bytes = parcel.marshall()
  parcel.recycle()

  return bytes.toBase64String()
}

@SuppressLint("NewApi")
private fun ByteArray.toBase64String(): String {
  return if (shouldUseJavaUtil) {
    java.util.Base64.getUrlEncoder().encodeToString(this)
  } else {
    Base64.encodeToString(this, Base64.URL_SAFE or Base64.NO_WRAP)
  }
}

private fun <T : Parcelable> base64ToParcelable(base64: String, creator: Parcelable.Creator<T>): T {
  val bytes = base64.base64ToByteArray()
  val parcel = unmarshall(bytes)
  val result = creator.createFromParcel(parcel)
  parcel.recycle()

  return result
}

fun String.base64ToByteArray(): ByteArray {
  return if (shouldUseJavaUtil) {
    java.util.Base64.getUrlDecoder().decode(toByteArray(StandardCharsets.UTF_8))
  } else {
    Base64.decode(toByteArray(StandardCharsets.UTF_8), Base64.URL_SAFE or Base64.NO_WRAP)
  }
}

private fun unmarshall(bytes: ByteArray): Parcel {
  val parcel = Parcel.obtain()
  parcel.unmarshall(bytes, 0, bytes.size)
  parcel.setDataPosition(0)

  return parcel
}

@Suppress("UNCHECKED_CAST")
private fun <T : Parcelable> parcelableClassForName(className: String): Class<T> {
  return Class.forName(className) as Class<T>
}

private val Class<out Parcelable>.isFinal get() = !isInterface && Modifier.isFinal(modifiers)

@Suppress("UNCHECKED_CAST")
private val <T> Class<T>.parcelableCreator
  get(): Parcelable.Creator<T> {
    return try {
      val creatorField = getField("CREATOR")
      creatorField.get(null) as Parcelable.Creator<T>
    } catch (e: Exception) {
      throw BadParcelableException(e)
    } catch (t: Throwable) {
      throw BadParcelableException(t.message)
    }
  }

// Both encode/decode from java until and android util seem to do exactly the same. android.util one doesn't work on Unit tests
// and java.util doesn't work on older devices. Also, on unit tests SDK_INT is 0, but we're running on the developer's machine
// So we can still use java.util in that case
@SuppressLint("ObsoleteSdkInt")
private val isRunningOnUnitTests = Build.VERSION.SDK_INT == 0

private val shouldUseJavaUtil = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O || isRunningOnUnitTests private const val DELIMITER = "@"

fun <T : Parcelable> T.toRouteString(): String {
  return javaClass.name + DELIMITER + toBase64()
}

fun <T : Parcelable> fromRouteSting(routeString: String, type: Class<T>): T {
  val (className, base64) = routeString.split(DELIMITER).let { it[0] to it[1] }

  val creator = if (type.isFinal) {
    // Since we have this, small optimisation to avoid additional reflection call of Class.forName
    type.parcelableCreator
  } else {
    // If our class is not final, then we must use the actual class from "className"
    parcelableClassForName<T>(className).parcelableCreator
  }

  return base64ToParcelable(base64, creator)
}

private fun Parcelable.toBase64(): String {
  val parcel = Parcel.obtain()
  writeToParcel(parcel, 0)
  val bytes = parcel.marshall()
  parcel.recycle()

  return bytes.toBase64String()
}

@SuppressLint("NewApi")
private fun ByteArray.toBase64String(): String {
  return if (shouldUseJavaUtil) {
    java.util.Base64.getUrlEncoder().encodeToString(this)
  } else {
    Base64.encodeToString(this, Base64.URL_SAFE or Base64.NO_WRAP)
  }
}

private fun <T : Parcelable> base64ToParcelable(base64: String, creator: Parcelable.Creator<T>): T {
  val bytes = base64.base64ToByteArray()
  val parcel = unmarshall(bytes)
  val result = creator.createFromParcel(parcel)
  parcel.recycle()

  return result
}

fun String.base64ToByteArray(): ByteArray {
  return if (shouldUseJavaUtil) {
    java.util.Base64.getUrlDecoder().decode(toByteArray(StandardCharsets.UTF_8))
  } else {
    Base64.decode(toByteArray(StandardCharsets.UTF_8), Base64.URL_SAFE or Base64.NO_WRAP)
  }
}

private fun unmarshall(bytes: ByteArray): Parcel {
  val parcel = Parcel.obtain()
  parcel.unmarshall(bytes, 0, bytes.size)
  parcel.setDataPosition(0)

  return parcel
}

@Suppress("UNCHECKED_CAST")
private fun <T : Parcelable> parcelableClassForName(className: String): Class<T> {
  return Class.forName(className) as Class<T>
}

private val Class<out Parcelable>.isFinal get() = !isInterface && Modifier.isFinal(modifiers)

@Suppress("UNCHECKED_CAST")
private val <T> Class<T>.parcelableCreator
  get(): Parcelable.Creator<T> {
    return try {
      val creatorField = getField("CREATOR")
      creatorField.get(null) as Parcelable.Creator<T>
    } catch (e: Exception) {
      throw BadParcelableException(e)
    } catch (t: Throwable) {
      throw BadParcelableException(t.message)
    }
  }

// Both encode/decode from java until and android util seem to do exactly the same. android.util one doesn't work on Unit tests
// and java.util doesn't work on older devices. Also, on unit tests SDK_INT is 0, but we're running on the developer's machine
// So we can still use java.util in that case
@SuppressLint("ObsoleteSdkInt")
private val isRunningOnUnitTests = Build.VERSION.SDK_INT == 0

private val shouldUseJavaUtil = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O || isRunningOnUnitTests What will the navigation look like now? Let’s modify our previous example: Modified example @Composable
fun MyApp() {
  val navController = rememberNavController()

  NavHost(navController = navController, startDestination = "home") {
    composable("home") { HomeScreen(navController) }
    composableWithData<Details>("$result/{$NAVIGATION_DATA_ARGUMENT}") { navigationArguments ->
      DetailsScreen(details = navigationArguments)
    }
  }
}

@Composable
fun HomeScreen(navController: NavController) {
  Column {
    Text("Home Screen")
    val details = Details(
      title = “Hello world!”,
      details = “Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor.”
    )
    Button(onClick = { navigateWithArguments(“details”, details) }) {
      Text("Go to Details")
    }
  }
}

@Composable
fun DetailsScreen(details: Details) {
  Text(title)
  Text(description)
}

@Parcelable
data class Details(
  val title: String,
  val description: String,
) @Composable
fun MyApp() {
  val navController = rememberNavController()

  NavHost(navController = navController, startDestination = "home") {
    composable("home") { HomeScreen(navController) }
    composableWithData<Details>("$result/{$NAVIGATION_DATA_ARGUMENT}") { navigationArguments ->
      DetailsScreen(details = navigationArguments)
    }
  }
}

@Composable
fun HomeScreen(navController: NavController) {
  Column {
    Text("Home Screen")
    val details = Details(
      title = “Hello world!”,
      details = “Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor.”
    )
    Button(onClick = { navigateWithArguments(“details”, details) }) {
      Text("Go to Details")
    }
  }
}

@Composable
fun DetailsScreen(details: Details) {
  Text(title)
  Text(description)
}

@Parcelable
data class Details(
  val title: String,
  val description: String,
) This approach simplifies data management by removing the need for a database. Once set up, the code can be reused across multiple screens, reducing development effort. Additionally, it offers flexibility; you can navigate to screens without input data using the standard composable() function. However, passing entire data classes as navigation arguments may not be suitable for large or complex objects. In such cases, consider alternative methods like using a Shared ViewModel or passing only the necessary identifiers and retrieving the data in the destination screen.

Build Cleaner Navigation in Jetpack Compose With Just a Few Lines of Code

I used to laugh at the meme that emacs could be used for everything and thought it crazy that one would "live in emacs" (that is a post from almost two years ago where I didn't even really believe it myself). live in emacs But, alas, if one allows himself to be swept away and gets far enough down the rabbit hole, he comes to find that a computer could have been a fully integrated environment within which the user's mind and machine were melded. While the advent of "brain-computer interfaces" is dinner table conversation (at conspiracy theorist households like my own) - there have, since the year 1976, been emacs - the closest thing to this aspirational place of man/machine integration that has ever existed. could have been Do I for one second believe that this is the way everyone should use a computer? everyone No. I don't have delusions of Emacs-grandeur. The significant investment it requires to get to the point where one could rely entirely on emacs as his computing environment is overwhelming for most. Does the person who bought a MacBook Pro to watch Netflix and "do email" need Emacs' integrated text interface? Probably not - it would be like using a hole hawg (shout out to Neal Stephenson for the analogy) for a 1/16th-inch screw. hole hawg Neal Stephenson for the analogy But, if you are a programmer, writer, creative, business owner, or just someone with ADHD, the question of whether to emacs or not to emacs becomes one worth considering. Do you spend hours manipulating text in any form? Do you want to automate workflows, creating tailored tools that are perfect just for you? Then emacs may be what you've always been looking for but never knew existed. Is it worthwhile? Is emacs the best way to use a computer? Well, I am penning this article after all, so there might be a bit of bias on my behalf. But I would say, unequivocally, yes - The investment has paid me back in droves, and will continue to do so for the rest of my natural computing life. As an aside, in the book, Stephenson discusses unix, but he does name-drop emacs as his editor de jour and has this to say about it: As an aside, in the book, Stephenson discusses unix, but he does name-drop emacs as his editor de jour and has this to say about it: I use emacs, which might be thought of as a thermonuclear word processor. It was created by Richard Stallman; enough said. It is written in Lisp, which is the only computer language that is beautiful. It is colossal, and yet it only edits straight ASCII text files, which is to say, no fonts, no boldface, no underlining. In other words, the engineer-hours that, in the case of Microsoft Word, were devoted to features like mail merge, and the ability to embed feature-length motion pictures in corporate memoranda, were, in the case of emacs, focused with maniacal intensity on the deceptively simple-seeming problem of editing text. If you are a professional writer–i.e., if someone else is getting paid to worry about how your words are formatted and printed–emacs outshines all other editing software in approximately the same way that the noonday sun does the stars. It is not just bigger and brighter; it simply makes everything else vanish. I use emacs, which might be thought of as a thermonuclear word processor. It was created by Richard Stallman; enough said. It is written in Lisp, which is the only computer language that is beautiful. It is colossal, and yet it only edits straight ASCII text files, which is to say, no fonts, no boldface, no underlining. In other words, the engineer-hours that, in the case of Microsoft Word, were devoted to features like mail merge, and the ability to embed feature-length motion pictures in corporate memoranda, were, in the case of emacs, focused with maniacal intensity on the deceptively simple-seeming problem of editing text. If you are a professional writer–i.e., if someone else is getting paid to worry about how your words are formatted and printed–emacs outshines all other editing software in approximately the same way that the noonday sun does the stars. It is not just bigger and brighter; it simply makes everything else vanish. Unfathomably based. Unfathomably based. Why Would You Want to Do This? Why would you want one tool to master them all? Why would you want to do everything in one place? And, why would you want to use almost 50-year-old software to do it? almost 50-year-old software While there are several arguments for using emacs (including dunking on normies) - the real arguments generally revolve around the solution to the problem of context switching, the deep integration of the tooling with each and every part of the overarching environment, and the customizability, programmability, and overall personalization that emacs affords the end user (leaps and bounds above anything available today, yes even neovim with lua support). So, while I will refrain from "dunking on normies" it has really come down to one word - flow. flow In one sentence? Context switching is extremely expensive for a knowledge worker. Context switching is extremely expensive for a knowledge worker. In one very long-winded paragraph? Neurological studies have recently stated that the cost of context switching and multitasking is something like 60% of our time in daily work. This is massive - it takes 23 minutes to get back on task after losing focus. One study even went so far as to say "context switching is the main productivity killer for developers." And, while I will be the first to tell you that productivity can very quickly devolve into procrastination, even a 20% boost in an 8-hour day is nothing to sneeze at. It is blatantly clear that if we want to get more done, we have to guard our focused time as if it were gold - emacs has become that guardrail more and more. Neurological studies have recently stated that the cost of context switching and multitasking is something like 60% of our time in daily work. This is massive - it takes 23 minutes to get back on task after losing focus. One study even went so far as to say "context switching is the main productivity killer for developers." And, while I will be the first to tell you that productivity can very quickly devolve into procrastination, even a 20% boost in an 8-hour day is nothing to sneeze at. It is blatantly clear that if we want to get more done, we have to guard our focused time as if it were gold - emacs has become that guardrail more and more. 23 minutes to get back on task after losing focus context switching is the main productivity killer for developers productivity can very quickly devolve into procrastination Because of the philosophy of everything being accessible from one interface, there is far less distraction than if I were back and forth among 12 different apps and tools. The environment itself has become a place of ultimate productivity. Because of the philosophy of everything being accessible from one interface, there is far less distraction than if I were back and forth among 12 different apps and tools. The environment itself has become a place of ultimate productivity. less distraction While I say flow, what I actually mean is harmony integration, dare I say oneness with the environment. Emacs is the only thing in town that allows you an ultimate "unified cognitive model" for interacting with text. And, if you know anything about computers, everything is text. harmony integration oneness everything is text While Donald Trump may say "Wow - everything's computer", the computer says "Everything's text." This cannot be overstated - when we simplify everything to text in a computing environment, we actually empower it to the highest possible level. In doing so, everything becomes searchable, reproducible, version-controlled, and infinitely malleable. Text can then be completely crafted and molded in whatever way we say fit. By keeping the text as text and not abstracting it away in some proprietary garbage way, we are empowered as the user. Everything Everywhere All At Once When you go to write an email, you have to perform the following: open your email client, click "compose message", find the contact you want to email, write the email, proofread it, and then send it. If you were doing something else beforehand, the flow state that you had potentially been in is all but gone, and now, it will take you some time to ramp up again to that same focused place. Instead, you could have captured a "TODO" in your inbox.org file in about 3 seconds and continued what you were doing until such a time that writing the email was pertinent. You then return to what you were doing without a single context switch, continuing on in that juicy flow state. When you go to write said email, you will do so in emacs' MU4E mode, taking that todo and (perhaps the associated contact) write the email, send it, and even include the work that you were not interrupted in doing. Emails are text, so you get all the powerful editor tools (autocomplete, spellcheck, snippets, etc.) in house, and write that email in likely half the time were you to have done so in Office365/Thunderbird/Gmail/whatever-people-use-these-days. not interrupted in doing Now, if this didn't light up your eyes a little bit at the possibilities, emacs may not be for you. But, if you grasp the difference here, now know that you can do this across all workflows, in all cases, and across your entire machine. Emacs becomes your operating system in which you do everything (except heavy image/video workflow or browsing the modern web.) everything What this means, too, is that there are no "separate" key binds or UIs to learn; you have everything contained in one place that is self-documenting, accessible, and continually iterable which you make into whatever you want. Your Tool Is Your Own The fact that VS Code is so widely adopted because one can get "up and running" quickly makes sense. But, if you want VS Code to be your own, I wish you all of the luck in the world. Emacs is fully open source & free (as in beer, and as in freedom) software that you can craft to your every need. The tool gets out of your way, and also becomes what you need it to become - it becomes an extension of the mind of the user rather than a box within which the user must operate. First Principles "But emacs is OLD" So is your grandfather, you don't treat him any differently do you? He could still whoop your ass if you got out of line, couldn't he? Emacs was built at a time when we respected computing first principles. Emacs isn't some arbitrary system, in which you do things for no reason. No - you come to find that everything in emacs (with the exception of playing chess or Tetris) has a reason for being the way that it is. chess or Tetris I thought, for example, I could build a "better org-mode" - I would have been battling with some of the greatest minds in computing to do so. Do I have that much faith in myself? I don't think I have enough faith in myself to remember to turn the dishwasher on at night. Emacs is also not "against the UNIX principle" as so many people leaped to claim in my video about coming back to the Church of Emacs. Emacs actually extends unix tooling far beyond what would be possible with bash scripting alone. You have a language (elisp) that you can call Unix tools. video about coming back to the Church of Emacs extends unix tooling Your editor is now completely programmatic - you can make it do whatever you need it to, and more. A Lifetime Computer My Current Computing Environment Entirely Contained in Emacs As I said in my video, to see the configuration of someone who has been using emacs for 30 years (and there are many of them on r/emacs) is a glimpse into a lifetime of computing. That lisp function that does that esoteric little thing? That's a man's mind. Emacs is a lifetime editor in a way that no other could possibly be - because it grows with you, pushing the boundaries at every major update version, and allows one to live a life of plain text that is a dream. r/emacs My Current Computing Environment Is Entirely Contained in Emacs Email - Mu4e Mu4e Development - treemacs (sidebar), vterm (integrated terminal), LSPs/major modes for my languages, restclient.el treemacs vterm restclient.el Version control - magit magit Docker - docker.el docker.el Databases - sql-mode and pgmacs sql-mode pgmacs AI integration - gptel and aider gptel aider Writing - org-mode, with occasional exports to markdown/html/latex/pdf org-mode Knowledgebase - org-roam org-roam Blogging - org-mode export to hugo Scheduling and TODOs - org-mode Calendar - calwf and org-gcal calwf org-gcal RSS - elfeed elfeed IRC - ERC ERC Music and media - EMMS EMMS Accounting - ledger-mode ledger-mode Light Browsing - EWW EWW File management - Dired and Dirvish Dired Dirvish Reading - calibredb, nov.el, pdf-tools, org-noter calibredb nov.el pdf-tools org-noter The End of the 'App' You will note that I have not once referred to emacs as an "app", and the reason for that is because that would be a massive understatement of what emacs is. Emacs has essentially become my entire computer. A place where I can do all things text and intellectual in one place. If I cannot do a task in emacs, I have become "that guy" - looking for the solution of how I can integrate a workflow, asking Claude to help me design custom lisp functions that allow me to use emacs in that 1% more that I do every day. If I can't do it in emacs, it probably involves heavy photo/video, browsing the modern web, or 3D rendering. All other workflows are completely fair game and likely have already been included in my ever-growing config.org (tangled to config.el). entire computer ever-growing config.org The only fair use of "app" would be "Life App" - but more akin to Life OS. On the Timesink Argument Those that do not want to sharpen the axe should not fell the tree. Those that do not want to sharpen the axe should not fell the tree. In our instant gratification culture, learning things that take time to learn is taboo. I have seen the argument that emacs is a massive time sink, one which could never possibly be re-cooped. But - how much time do you spend moving text around a screen? How much time do you spend frustrated by how your computer doesn't do what you want it to? How much time have you spent looking for conversion tooling, or "how to do X in Word/excel/Gmail, etc." The funny thing has been that the argument often comes from the vim/neovim side of the editor war - but vim is just a text editor. Emacs literally runs Vim if you want it to. Vim users have to learn all the other tooling associated with a CLI/TUI workflow, which is just about the same investment as learning emacs! editor war runs Vim Not only this - emacs doesn't just return your time in spades, it allows you complete independence. While I have mulled over leaving the Linux desktop for the shiny walled garden of Apple, emacs would have allowed this in that it has become my actual computing environment. I don't really care so much about the OS anymore (just that it is unix based). I can go wherever the hardware is best - but I will hold off on the iCope and await AMD's crazy integrated chips because that sounds like exciting times! actual computing environment await AMD's crazy integrated chips Conclusion While I don't recommend losing yourself over your tooling, emacs is different if you are in a similar position to me. If you care about your personal autonomy and freedom, your ability to craft a system to your every need (and have it grow with you as you learn and find new paradigms), and the power of overcoming the productivity shortfalls of modern software, emacs is the one. It will continue to be the one for me as I go forward in this journey, it will be with me when I write that next book, build that next company, or just simply dump what's on my mind into a journal. Emacs was born in a time that cared about design, about first principles, and about longevity. As such, nothing has come close to emacs in 50 years, and I would be willing to bet nothing will in the next 50 years. It is not "trendy" or "hype" as the kids say - it is an embodiment of how humans think, about how we can augment that thinking with software, and the relevance of the guiding principles of emacs are timeless. As always, God bless, and until next time. If you enjoyed this post, consider supporting my work by Buying me a Coffee, Checking out my book, or sending me an email to tell me what you think. Buying me a Coffee Checking out my book email

To Emacs or Not to Emacs

Break Hidden Dependencies for Cleaner Code TL;DR: Replace global variables with dependency injection to improve testability and reduce coupling. 💉 Problems Addressed 😔 Hidden Dependencies
Tight Coupling
Testing Challenges
Maintainability
Singletons Related Code Smells 💨 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii Steps 🛠️ Identify global variables used across your codebase.
Create a real-world abstraction to encapsulate these variables.
Pass dependencies explicitly via function parameters or constructors.
Refactor existing code to use the new dependency-injected structure.
Remove the original global variable declarations. Sample Code 💻 Before ❌ // This global variable holds the API configuration  
const globalConfig = { apiUrl: "https://api.severance.com" };  

function fetchOuties() {  
  return fetch(`${globalConfig.apiUrl}/outies`);  
  // globalConfig is NOT passed as parameter
} After 👉 function fetchOuties(parameterConfig) {  
  return fetch(`${parameterConfig.apiUrl}/outies`);  
  // 1. Identify global variables
  // used across your codebase.
  // 4. Refactor the existing code 
  // to use the new dependency-injected structure. 
}  

const applicationConfig = { apiUrl: "https://api.severance.com" };  
// 2. Create a real-world abstraction
// to encapsulate these variables.

fetchOuties(applicationConfig); 
// 3. Pass dependencies explicitly 
// via function parameters or constructors.

//  const globalConfig = { apiUrl: "https://api.severance.com" };  
// 5. Remove the original 
// global variable declarations.

// Why Is 'config' a Dependency?
// Because:
// outies() depends on knowing the API URL to work
// Without this information, 
// The function can't perform its core task
// The dependency is 
// explicitly declared in the function signature A Step Beyond: API Reification class ApiService {
  constructor(parameterConfig) {
    this.variableConfig = parameterConfig;
  }
  
  // parameterConfig, variableConfig
  // and applicationConfig
  // are very bad names. 
  // They are here to emphasize the change

  fetchOuties() {
    return fetch(`${this.variableConfig.apiUrl}/outies`);
  }
}

const apiService = 
  new ApiService({ apiUrl: "https://api.severance.com" });
apiService.fetchOuties(); Type 📝 [x]Semi-Automatic Safety 🛡️ This refactoring is safe if you audit all global variable references and thoroughly test the code after injection. Why is the Code Better? 🌱 Testability: Dependencies can be replaced (not mocked) for unit tests. Explicit Contracts: Functions declare what they need. Scalability: Configuration changes don’t require code edits. Coupling: Code is less coupled. How Does it Improve the Bijection? 🗺️ By making dependencies explicit, the code mirrors real-world interactions where components rely on declared inputs, not hidden state. You also reduce Coupling which is usually the more important problem you must solve. Limitations ⚠️ Over-injection can lead to parameter bloat. Common Misconceptions "But it's just a parameter!" Exactly! Passing dependencies via parameters is Dependency Injection. Frameworks often obscure this basic principle. "This is too simple to be DI!" Dependency Injection doesn't require complex frameworks. This is a pure, framework-less injection. "Dependency Injection vs Dependency Inversion" Inversion is the principle (why). It tells you to depend on abstractions to reduce coupling.
Injection is the practice (how). It’s one way (there are many others) to apply the principle by passing dependencies from outside instead of creating them inside a class. Refactor with AI 🤖 You can use AI tools to analyze your codebase and identify global variables. The AI can suggest where to implement dependency injection and help generate the necessary interfaces or classes for your dependencies. Try Them! 🛠 Remember: AI Assistants make lots of mistakes Suggested Prompt: 1. Identify global variables used across your codebase.2. Create a real-world abstraction to encapsulate these variables. 3. Pass dependencies explicitly via function parameters or constructors. 4. Refactor existing code to use the new dependency-injected structure. 5. Remove the original global variable declarations. Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini



DeepSeek

DeepSeek



Meta AI

Meta AI



Qwen

Qwen Tags 🏷️ Dependency Injection Level 🔋 [x]Intermediate Related Refactorings 👩‍❤️‍💋‍� https://hackernoon.com/refactoring-018-how-to-replace-a-singleton?embedable=true https://refactoring.guru/es/introduce-parameter-object?embedable=true See also 🔍 https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true https://hackernoon.com/singleton-pattern-the-root-of-all-evil-e4r3up7?embedable=true https://en.wikipedia.org/wiki/Dependency_injection?embedable=true https://en.wikipedia.org/wiki/Dependency_inversion_principle?embedable=true Credits 🙏 Image by Petra on Pixabay This article is part of the Refactoring Series. https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true Break Hidden Dependencies for Cleaner Code Break Hidden Dependencies for Cleaner Code TL;DR: Replace global variables with dependency injection to improve testability and reduce coupling. 💉 TL;DR: Replace global variables with dependency injection to improve testability and reduce coupling. 💉 Problems Addressed 😔 Hidden Dependencies Tight Coupling Testing Challenges Maintainability Singletons Hidden Dependencies Tight Coupling Coupling Testing Challenges Maintainability Singletons Singletons Related Code Smells 💨 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxii Steps 🛠️ Identify global variables used across your codebase. Create a real-world abstraction to encapsulate these variables. Pass dependencies explicitly via function parameters or constructors. Refactor existing code to use the new dependency-injected structure. Remove the original global variable declarations. Identify global variables used across your codebase. Create a real-world abstraction to encapsulate these variables. Pass dependencies explicitly via function parameters or constructors. Refactor existing code to use the new dependency-injected structure. Remove the original global variable declarations. Sample Code 💻 Before ❌ // This global variable holds the API configuration  
const globalConfig = { apiUrl: "https://api.severance.com" };  

function fetchOuties() {  
  return fetch(`${globalConfig.apiUrl}/outies`);  
  // globalConfig is NOT passed as parameter
} // This global variable holds the API configuration  
const globalConfig = { apiUrl: "https://api.severance.com" };  

function fetchOuties() {  
  return fetch(`${globalConfig.apiUrl}/outies`);  
  // globalConfig is NOT passed as parameter
} After 👉 function fetchOuties(parameterConfig) {  
  return fetch(`${parameterConfig.apiUrl}/outies`);  
  // 1. Identify global variables
  // used across your codebase.
  // 4. Refactor the existing code 
  // to use the new dependency-injected structure. 
}  

const applicationConfig = { apiUrl: "https://api.severance.com" };  
// 2. Create a real-world abstraction
// to encapsulate these variables.

fetchOuties(applicationConfig); 
// 3. Pass dependencies explicitly 
// via function parameters or constructors.

//  const globalConfig = { apiUrl: "https://api.severance.com" };  
// 5. Remove the original 
// global variable declarations.

// Why Is 'config' a Dependency?
// Because:
// outies() depends on knowing the API URL to work
// Without this information, 
// The function can't perform its core task
// The dependency is 
// explicitly declared in the function signature function fetchOuties(parameterConfig) {  
  return fetch(`${parameterConfig.apiUrl}/outies`);  
  // 1. Identify global variables
  // used across your codebase.
  // 4. Refactor the existing code 
  // to use the new dependency-injected structure. 
}  

const applicationConfig = { apiUrl: "https://api.severance.com" };  
// 2. Create a real-world abstraction
// to encapsulate these variables.

fetchOuties(applicationConfig); 
// 3. Pass dependencies explicitly 
// via function parameters or constructors.

//  const globalConfig = { apiUrl: "https://api.severance.com" };  
// 5. Remove the original 
// global variable declarations.

// Why Is 'config' a Dependency?
// Because:
// outies() depends on knowing the API URL to work
// Without this information, 
// The function can't perform its core task
// The dependency is 
// explicitly declared in the function signature A Step Beyond: API Reification class ApiService {
  constructor(parameterConfig) {
    this.variableConfig = parameterConfig;
  }
  
  // parameterConfig, variableConfig
  // and applicationConfig
  // are very bad names. 
  // They are here to emphasize the change

  fetchOuties() {
    return fetch(`${this.variableConfig.apiUrl}/outies`);
  }
}

const apiService = 
  new ApiService({ apiUrl: "https://api.severance.com" });
apiService.fetchOuties(); class ApiService {
  constructor(parameterConfig) {
    this.variableConfig = parameterConfig;
  }
  
  // parameterConfig, variableConfig
  // and applicationConfig
  // are very bad names. 
  // They are here to emphasize the change

  fetchOuties() {
    return fetch(`${this.variableConfig.apiUrl}/outies`);
  }
}

const apiService = 
  new ApiService({ apiUrl: "https://api.severance.com" });
apiService.fetchOuties(); Type 📝 [x]Semi-Automatic [x] Semi-Automatic [x] Safety 🛡️ This refactoring is safe if you audit all global variable references and thoroughly test the code after injection. Why is the Code Better? 🌱 Testability: Dependencies can be replaced (not mocked ) for unit tests. mocked Explicit Contracts: Functions declare what they need. Scalability: Configuration changes don’t require code edits. Coupling: Code is less coupled. How Does it Improve the Bijection? 🗺️ By making dependencies explicit, the code mirrors real-world interactions where components rely on declared inputs, not hidden state. real-world You also reduce Coupling which is usually the more important problem you must solve. Coupling Limitations ⚠️ Over-injection can lead to parameter bloat . parameter bloat Common Misconceptions "But it's just a parameter!" Exactly! Passing dependencies via parameters is Dependency Injection. Frameworks often obscure this basic principle. Exactly! Passing dependencies via parameters is Dependency Injection . Frameworks often obscure this basic principle. Dependency Injection "This is too simple to be DI!" Dependency Injection doesn't require complex frameworks. This is a pure, framework-less injection. Dependency Injection doesn't require complex frameworks. This is a pure, framework-less injection. "Dependency Injection vs Dependency Inversion" Inversion is the principle (why). It tells you to depend on abstractions to reduce coupling. Injection is the practice (how). It’s one way (there are many others) to apply the principle by passing dependencies from outside instead of creating them inside a class. Inversion is the principle (why). It tells you to depend on abstractions to reduce coupling. Inversion Injection is the practice (how). It’s one way (there are many others) to apply the principle by passing dependencies from outside instead of creating them inside a class. Refactor with AI 🤖 You can use AI tools to analyze your codebase and identify global variables. The AI can suggest where to implement dependency injection and help generate the necessary interfaces or classes for your dependencies. Try Them! 🛠 Remember: AI Assistants make lots of mistakes Remember: AI Assistants make lots of mistakes Suggested Prompt: 1. Identify global variables used across your codebase.2. Create a real-world abstraction to encapsulate these variables. 3. Pass dependencies explicitly via function parameters or constructors. 4. Refactor existing code to use the new dependency-injected structure. 5. Remove the original global variable declarations. Suggested Prompt: 1. Identify global variables used across your codebase.2. Create a real-world abstraction to encapsulate these variables. 3. Pass dependencies explicitly via function parameters or constructors. 4. Refactor existing code to use the new dependency-injected structure. 5. Remove the original global variable declarations. Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini



DeepSeek

DeepSeek



Meta AI

Meta AI



Qwen

Qwen Without Proper Instructions

With Specific Instructions ChatGPT

ChatGPT Claude

Claude Perplexity

Perplexity Copilot

Copilot Gemini

Gemini DeepSeek

DeepSeek Meta AI

Meta AI Qwen

Qwen Without Proper Instructions With Specific Instructions Without Proper Instructions Without Proper Instructions With Specific Instructions With Specific Instructions ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT Claude Claude Claude Claude Claude Claude Claude Claude Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Copilot Copilot Copilot Copilot Copilot Copilot Copilot Copilot Gemini Gemini Gemini Gemini Gemini Gemini Gemini Gemini DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek Meta AI Meta AI Meta AI Meta AI Meta AI Meta AI Meta AI Meta AI Qwen Qwen Qwen Qwen Qwen Qwen Qwen Qwen Tags 🏷️ Dependency Injection Dependency Injection Level 🔋 [x]Intermediate [x] Intermediate [x] Related Refactorings 👩‍❤️‍💋‍� https://hackernoon.com/refactoring-018-how-to-replace-a-singleton?embedable=true https://hackernoon.com/refactoring-018-how-to-replace-a-singleton?embedable=true https://refactoring.guru/es/introduce-parameter-object?embedable=true https://refactoring.guru/es/introduce-parameter-object?embedable=true See also 🔍 https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true https://hackernoon.com/singleton-pattern-the-root-of-all-evil-e4r3up7?embedable=true https://hackernoon.com/singleton-pattern-the-root-of-all-evil-e4r3up7?embedable=true https://en.wikipedia.org/wiki/Dependency_injection?embedable=true https://en.wikipedia.org/wiki/Dependency_injection?embedable=true https://en.wikipedia.org/wiki/Dependency_inversion_principle?embedable=true https://en.wikipedia.org/wiki/Dependency_inversion_principle?embedable=true Credits 🙏 Image by Petra on Pixabay Petra Pixabay This article is part of the Refactoring Series. https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true

Stories, News & Mentions about REIF

Categories

Trending Topics

Stories, News & Mentions about REIF

Reif’s Stories on HackerNoon

Reif's News & Mentions

Categories

Trending Topics