DEV Community: Belli

Mixins in Dart: A Better Way to Share Code

Belli — Wed, 13 Aug 2025 09:57:25 +0000

The official (and confusing) documentation of mixins in Dart does not highlight — at least not for me — the usefulness of this amazing property. Programming is literally having the knowledge of a new language and as developers, our job is to understand the language we're "speaking." The deeper our understanding, the more valuable our solutions can be.

Mixins allow software to make use of an important concept from the SOLID principles: the O — Open/Closed Principle.
This principle states that software entities such as classes, modules, and functions should be open for extension but closed for modification. In other words, you should be able to add new functionality to your code without changing existing, stable code.

The bigger the project, the more important it is to follow this principle. Consider a scenario where multiple devs are working on a feature at the same time, or even more critical, when the project lacks test coverage to guarantee existing functionalities. Modifying a class, even if it doesn’t break the code immediately, will eventually cause problems at some edge case (If you haven’t been there yet, don’t worry, you will).

All this introduction to explain a “simple” concept: class extension without hierarchies.

A mixin in Dart is a way to reuse a class’s code in multiple class hierarchies. Mixins let you add methods and properties to classes without using inheritance.

Key differences:

A normal class can be instantiated (you can create objects from it), while a mixin cannot.
A mixin is used to add functionality to other classes, not to create objects.
You use the with keyword to apply a mixin to a class.

Let’s see an example of usage in code:

mixin Logger {
  void log(String message) => print('Log: $message');
}

class MyClass with Logger {}

void main() {
  MyClass().log('Hello'); // prints: Log: Hello
}

In Summary

Use mixins to share code and add new behaviors to classes without creating a rigid inheritance hierarchy. They're a flexible and powerful tool for adhering to the Open/Closed Principle and keeping your codebase clean and modular.

Thank you AI

Belli — Wed, 06 Nov 2024 19:52:53 +0000

Have you said thank you to your AI buddy lately?
It increases my productivity so much that I have to show some gratitude 😆

Lazy or productive?

Belli — Wed, 23 Oct 2024 15:00:00 +0000

As a heavy user of both #IntelliJ and #Xcode, I’ve gotten used to working with Git almost entirely within the IDE. These tools make it so easy to handle version control that using the terminal for simple tasks feels unnecessary. For senior developers juggling many responsibilities, it's tempting to prioritize efficiency and rely on the ‘quickest’ methods to free up time for more complex work.

However, this convenience comes with a potential downside—by relying too much on these tools, we may lose touch with the core concepts of version control. When everything is done through the interface, it’s easy to forget the manual steps behind Git’s commands and the deeper logic that drives them. This can make us less adaptable when troubleshooting issues or when working outside the safety net of an IDE.

Code versioning is essential for all developers, no matter their level of seniority. Whether you're just starting out or you're years into your career, understanding how Git works behind the scenes is crucial. While IDE integrations can boost productivity, they shouldn't replace a solid grasp of versioning fundamentals.

Mastering these fundamentals—not just how to use Git, but how it actually operates—keeps us adaptable and better equipped to handle complex scenarios. It’s this foundational knowledge that empowers developers to work smarter, not just faster, and ensures we don’t lose sight of the bigger picture in pursuit of convenience.

In Version Control course from #Meta, I gained a deeper understanding of not only Git but version control systems as a whole. The course provided hands-on practices to manually execute Git’s features, helping me thoroughly grasp how they function, their terminologies, and best practices - It even covered some Unix commands along the way!

I highly recommend this course to anyone looking to deepen their understanding of Git and improve their version control skills.

Backend VS Frontend 🤷‍♂️

Belli — Tue, 22 Oct 2024 16:53:46 +0000

(From a Mobile Engineer perspective)

As a Mobile engineer I have to admit, most of the jobs I had recently envolves way more than just the FrontEnd. BUT (and this is a big "but")—no one wants to use an app that looks unpolished, isn’t responsive, or ignores fundamental UX principles. This may sound like an advertisement for my field, but creating an app/website that is not only beautiful but also intuitive and easy to use is far from simple. Saying "anyone can do it" really oversimplifies the work involved.

Sure, anyone can slap together a basic UI, but what’s the point of having a robust backend if the user experience is frustrating? End users don’t care about your tech stack—they care about how the app feels in their hands. For a product to succeed, both the Frontend and Backend need to work in harmony.
While it’s true that someone with time and dedication can learn backend concepts ~~—since it’s more structured and logical—~~ it’s a misconception to think frontend is just a matter of "throwing things together".

I’m obviously not saying that backend is easy to learn—there are plenty of concepts and different technologies to master—but saying that frontend can be easily done by anyone is equally absurd. UI/UX design demands creativity, empathy, and a keen eye for detail. Without that passion for creation, even with all the knowledge in the world, frontend work can feel like a frustrating, never-ending chore.

If a frontend role requires backend knowledge, it’s because there’s an underlying expectation that the developer is already well-versed in UI/UX. Otherwise, users will not connect with the product, no matter how good the backend is.