--- title: "Software Engineering Principles Every Developer Should Know" lang: "en" author: "Mohammad Abu Mattar" canonical: https://mkabumattar.com/post/software-engineering-principles-every-developer-should-know --- ![Blog post image for Software Engineering Principles Every Developer Should Know - The software engineering principles every developer should know: DRY, KISS, and YAGNI. What each one asks of you, and Python examples of the same code before and after applying them.](/_astro/hero.D6DACa0__1LzEpL.webp) [Home](/)›[Blog](/blog)›[All Categories](/blog/categories)›[Software Engineering](/blog/categories/software-engineering) Blog [Prev in Software EngineeringRESTful API vs. GraphQL: Which API is the Right Choice for Your Project?](/blog/post/restful-api-vs-graphql-which-api-is-the-right-choice-for-your-project)[Next in Software EngineeringUnderstanding Generative AI in Depth](/blog/post/understanding-generative-ai-in-depth) [Software Engineering](/blog/categories/software-engineering)[Programming Principles](/blog/categories/programming-principles)[Code Quality](/blog/categories/code-quality)[Best Practices](/blog/categories/best-practices) # Software Engineering Principles Every Developer Should Know [Mohammad Abu Mattar](/authors/mohammad-abu-mattar)Published: 20 May 202403 Mins read04 Mins listen [Markdown for AI(opens in a new tab)](/post/software-engineering-principles-every-developer-should-know/index.md "Open the plain-Markdown version of this page, for pasting into an AI tool") TL;DR The software engineering principles every developer should know: DRY, KISS, and YAGNI. What each one asks of you, and Python examples of the same code before and after applying them. Series [Software Engineering Craft](/series/software-engineering-craft)2/6 [PreviousUnderstanding Software Versioning](/blog/post/how-version-number-software-works)[NextHow to Avoid Over-Engineering Your Code?](/blog/post/how-to-avoid-over-engineering-your-code) All posts in this series (6) Blog6 1. [Understanding Software Versioning](/blog/post/how-version-number-software-works) 2. [Software Engineering Principles Every Developer Should KnowYou are here](/blog/post/software-engineering-principles-every-developer-should-know) 3. [How to Avoid Over-Engineering Your Code?](/blog/post/how-to-avoid-over-engineering-your-code) 4. [Why You Should Not Use Else Statements in Your Code](/blog/post/why-you-should-not-use-else-statements) 5. [Getting Addicted to Coding: Why We Love Programming More Than Sleep](/blog/post/getting-addicted-to-coding) 6. [Low-Code vs. Custom Code: Let's Talk About Speed and Tech Debt](/blog/post/low-code-vs-custom-code-speed-tech-debt) ### Software Engineering Principles Every Developer Should Know Contents [What is the DRY principle, and why is it important?](#what-is-the-dry-principle-and-why-is-it-important)[How does the KISS principle improve software development?](#how-does-the-kiss-principle-improve-software-development)[What does YAGNI mean in software development?](#what-does-yagni-mean-in-software-development)[Conclusion](#conclusion)[References](#references) Some software engineering principles hold up no matter what stack you’re using. They guide you toward maintainable, efficient code. Here’s a look at why every developer should know them. ## [What is the DRY principle, and why is it important?](#what-is-the-dry-principle-and-why-is-it-important) **DRY (Don’t Repeat Yourself)** is about writing a piece of logic once and reusing it. - Avoid code duplication: repeating the same code in multiple places increases the risk of errors and makes maintenance harder. - Modularize code: break functionality into reusable modules or functions, which cuts duplication and keeps behaviour consistent. Here’s a common example in Python that doesn’t adhere to the DRY principle: without\_dry\_principle.py ``` 1def create_user_profile(user_id, name, email):2 profile = {3 "id": user_id,4 "name": name,5 "email": email,6 "welcome_message": f"Welcome {name}! Your email is {email}."7 }8 print(f"Creating profile for {name} with email {email}")9 return profile10 11def send_welcome_email(name, email):12 message = f"Hello {name}, welcome to our platform! Please verify your email: {email}."13 print(f"Sending email to {email}: {message}") ``` The above code repeats the process of constructing welcome messages. Let’s refactor it to adhere to the DRY principle: with\_dry\_principle.py ``` 1def format_welcome_message(name, email):2 return f"Hello {name}, welcome to our platform! Please verify your email: {email}."3 4def create_user_profile(user_id, name, email):5 profile = {6 "id": user_id,7 "name": name,8 "email": email,9 "welcome_message": format_welcome_message(name, email)10 }11 print(f"Creating profile for {name} with email {email}")12 return profile13 14def send_welcome_email(name, email):15 message = format_welcome_message(name, email)16 print(f"Sending email to {email}: {message}") ``` By creating a single function to format welcome messages, we eliminate redundancy and improve maintainability. ## [How does the KISS principle improve software development?](#how-does-the-kiss-principle-improve-software-development) **KISS (Keep It Simple, Stupid)** advocates for simplicity in design and implementation. - Clarity and readability: simple code is easier to understand, debug, and maintain. - Reduce complexity: avoid over-engineering by choosing straightforward solutions over unnecessarily complex ones. Consider the following Python code snippet for logging user activities: complex\_user\_logging.py ``` 1import logging2 3def log_user_activity(user_id, activity):4 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s')5 logger = logging.getLogger()6 log_message = f"User {user_id} performed {activity}."7 if activity == 'login':8 logger.debug(log_message)9 elif activity == 'logout':10 logger.debug(log_message)11 elif activity == 'error':12 logger.error(log_message)13 else:14 logger.info(log_message) ``` The above code is more complex than necessary. Let’s simplify it: simple\_user\_logging.py ``` 1import logging2 3logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s')4logger = logging.getLogger()5 6def log_user_activity(user_id, activity):7 log_message = f"User {user_id} performed {activity}."8 logger.log(logging.DEBUG if activity in ['login', 'logout'] else logging.INFO, log_message) ``` By using a more straightforward approach, we keep the same behaviour and the code is easier to read. ## [What does YAGNI mean in software development?](#what-does-yagni-mean-in-software-development) **YAGNI (You Aren’t Gonna Need It)** encourages developers to avoid adding functionality prematurely. - Focus on requirements: implement only the features that are currently needed, not the speculative ones. - Avoid over-engineering: when you build only what is needed, there is less complexity and less room for bugs. Consider the following Python code snippet for handling user permissions: over\_engineered\_permissions.py ``` 1def get_user_permissions(user_role, has_admin_rights, is_super_user, is_active):2 if not is_active:3 return "No permissions"4 if is_super_user:5 return "All permissions"6 if has_admin_rights:7 return "Admin permissions"8 if user_role == "editor":9 return "Edit permissions"10 if user_role == "viewer":11 return "View permissions"12 return "No permissions" ``` This code over-engineers the permissions logic. Let’s simplify it by focusing on essential functionality: simple\_permissions.py ``` 1def get_user_permissions(user_role):2 permissions = {3 "super_user": "All permissions",4 "admin": "Admin permissions",5 "editor": "Edit permissions",6 "viewer": "View permissions"7 }8 return permissions.get(user_role, "No permissions") ``` By adhering to the YAGNI principle, we eliminate unnecessary complexity and focus on core requirements. ## [Conclusion](#conclusion) Understanding and applying principles like DRY, KISS, and YAGNI makes a real difference in code quality and maintainability. They push you toward code reuse, simplicity, and building only what you actually need. ## [References](#references) 1. “Don’t repeat yourself.” Wikipedia, [https://en.wikipedia.org/wiki/Don%27t\_repeat\_yourself](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) 2. “KISS principle.” Wikipedia, [https://en.wikipedia.org/wiki/KISS\_principle](https://en.wikipedia.org/wiki/KISS_principle) 3. “You ain’t gonna need it (YAGNI).” Wikipedia, [https://en.wikipedia.org/wiki/You\_aren%27t\_gonna\_need\_it](https://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it) 4. Fowler, Martin. “Yagni.” MartinFowler.com, [https://martinfowler.com/bliki/Yagni.html](https://martinfowler.com/bliki/Yagni.html) 5. “SOLID Principles for C# Developers” - Atree (While C#-focused, SOLID principles are related and often discussed alongside DRY, KISS, YAGNI.), [https://www.atree.com.au/insights/solid-principles-for-c-developers/](https://www.atree.com.au/insights/solid-principles-for-c-developers/) 6. “Refactoring Guru: Code Smells.” (Discusses issues often solved by applying these principles.), [https://refactoring.guru/smells](https://refactoring.guru/smells) Was this useful? ## Tags [#DRY Principle](/blog/tags/dry-principle)[#KISS Principle](/blog/tags/kiss-principle)[#YAGNI Principle](/blog/tags/yagni-principle)[#Clean Code](/blog/tags/clean-code)[#Software Design](/blog/tags/software-design)[#Code Maintainability](/blog/tags/code-maintainability)[#Python](/blog/tags/python)[#Developer Productivity](/blog/tags/developer-productivity) ## Share [Facebook](https://facebook.com/sharer/sharer.php?u=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know "Share on Facebook")[Twitter](https://twitter.com/intent/tweet/?text=Software%20Engineering%20Principles%20Every%20Developer%20Should%20Know&url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know "Share on Twitter")[LinkedIn](https://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know&title=Software%20Engineering%20Principles%20Every%20Developer%20Should%20Know&summary=The%20software%20engineering%20principles%20every%20developer%20should%20know%3A%20DRY%2C%20KISS%2C%20and%20YAGNI.%20What%20each%20one%20asks%20of%20you%2C%20and%20Python%20examples%20of%20the%20same%20code%20before%20and%20after%20applying%20them.&source=https://mkabumattar.com "Share on LinkedIn")[WhatsApp](https://wa.me/?text=Software%20Engineering%20Principles%20Every%20Developer%20Should%20Know%20https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know "Share on WhatsApp")[Telegram](https://t.me/share/url?url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know&text=Software%20Engineering%20Principles%20Every%20Developer%20Should%20Know "Share on Telegram")[Reddit](https://www.reddit.com/submit?url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know&title=Software%20Engineering%20Principles%20Every%20Developer%20Should%20Know "Share on Reddit")[Hacker News](http://news.ycombinator.com/submitlink?u=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know&t=Software%20Engineering%20Principles%20Every%20Developer%20Should%20Know "Share on Hacker News")[Pinterest](https://pinterest.com/pin/create/button/?url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fsoftware-engineering-principles-every-developer-should-know&media=&description=The%20software%20engineering%20principles%20every%20developer%20should%20know%3A%20DRY%2C%20KISS%2C%20and%20YAGNI.%20What%20each%20one%20asks%20of%20you%2C%20and%20Python%20examples%20of%20the%20same%20code%20before%20and%20after%20applying%20them. "Share on Pinterest")[Email]() ## Comments ## You might also enjoy More posts on similar topics [![Why You Should Not Use Else Statements in Your Code](/_astro/hero.BtqcHltO_2kocMc.webp)](/blog/post/why-you-should-not-use-else-statements) ## [Why You Should Not Use Else Statements in Your Code](/blog/post/why-you-should-not-use-else-statements) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Software Engineering](/blog/categories/software-engineering) - [Programming Best Practices](/blog/categories/programming-best-practices) - [Code Quality](/blog/categories/code-quality) - [Refactoring](/blog/categories/refactoring) In software engineering, how you structure your code shapes its readability, maintainability, and overall quality. One often-debated topic is the use of else statements. They look straightforward, and [#Guard Clauses](/blog/tags/guard-clauses)[#Else Statements](/blog/tags/else-statements)[#Clean Code](/blog/tags/clean-code)+6 tags [read more](/blog/post/why-you-should-not-use-else-statements) [![How to Avoid Over-Engineering Your Code?](/_astro/hero.BBuBduRe_ZMrw4V.webp)](/blog/post/how-to-avoid-over-engineering-your-code) ## [How to Avoid Over-Engineering Your Code?](/blog/post/how-to-avoid-over-engineering-your-code) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Software Engineering](/blog/categories/software-engineering) - [Programming Best Practices](/blog/categories/programming-best-practices) - [Code Quality](/blog/categories/code-quality) - [Project Management](/blog/categories/project-management) Over-engineering is a common mistake in software development. It adds complexity, stretches out development, and leaves you with features nobody asked for. This post covers how to avoid over-engineeri [#Over Engineering](/blog/tags/over-engineering)[#Software Development](/blog/tags/software-development)[#Clean Code](/blog/tags/clean-code)+6 tags [read more](/blog/post/how-to-avoid-over-engineering-your-code) [![Understanding Software Versioning](/_astro/hero.DFRD27Ad_19S6oB.webp)](/blog/post/how-version-number-software-works) ## [Understanding Software Versioning](/blog/post/how-version-number-software-works) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Software Development](/blog/categories/software-development) - [Versioning](/blog/categories/versioning) - [DevOps](/blog/categories/devops) - [Best Practices](/blog/categories/best-practices) Introduction Software versioning is an important practice in software development that tracks changes and updates to a codebase. It provides a structured way to identify different iterations of a [#Semantic Versioning](/blog/tags/semantic-versioning)[#Software Versioning](/blog/tags/software-versioning)[#Release Management](/blog/tags/release-management)+6 tags [read more](/blog/post/how-version-number-software-works) [![Getting Addicted to Coding: Why We Love Programming More Than Sleep](/_astro/hero.DkXq96QT_2tnFpb.webp)](/blog/post/getting-addicted-to-coding) ## [Getting Addicted to Coding: Why We Love Programming More Than Sleep](/blog/post/getting-addicted-to-coding) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Programming](/blog/categories/programming) - [Career Development](/blog/categories/career-development) - [Developer Lifestyle](/blog/categories/developer-lifestyle) - [Mental Health](/blog/categories/mental-health) For a lot of people, coding stops being just a skill and turns into a passion, a lifestyle, and sometimes an obsession. But what makes programming so captivating? Why do some developers lose track of [#Coding Addiction](/blog/tags/coding-addiction)[#Programming Passion](/blog/tags/programming-passion)[#Developer Burnout](/blog/tags/developer-burnout)+5 tags [read more](/blog/post/getting-addicted-to-coding) [![Low-Code vs. Custom Code: Let's Talk About Speed and Tech Debt](/_astro/hero.sDsjchdO_2aAGxk.webp)](/blog/post/low-code-vs-custom-code-speed-tech-debt) ## [Low-Code vs. Custom Code: Let's Talk About Speed and Tech Debt](/blog/post/low-code-vs-custom-code-speed-tech-debt) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Low Code](/blog/categories/low-code) - [Custom Code](/blog/categories/custom-code) - [Technical Debt](/blog/categories/technical-debt) - [Internal Tools](/blog/categories/internal-tools) - [Software Development](/blog/categories/software-development) In the ever-changing world of making software, there's always this big question: how do we build things quickly without creating a mess down the road? That's where "low-code" development comes into pl [#Low Code](/blog/tags/low-code)[#Custom Code](/blog/tags/custom-code)[#Technical Debt](/blog/tags/technical-debt)+6 tags [read more](/blog/post/low-code-vs-custom-code-speed-tech-debt) [![AI is Not Real: A Software Engineering Perspective](/_astro/hero.zLRxEs_v_7tKSA.webp)](/blog/post/ai-is-not-real) ## [AI is Not Real: A Software Engineering Perspective](/blog/post/ai-is-not-real) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Artificial Intelligence](/blog/categories/artificial-intelligence) - [Software Engineering](/blog/categories/software-engineering) - [Machine Learning](/blog/categories/machine-learning) - [Technology Ethics](/blog/categories/technology-ethics) We have all seen the wave of hype around artificial intelligence. It is everywhere, from tech conferences to science fiction scripts. As software engineers, though, we need to look past the marketing [#AI Limitations](/blog/tags/ai-limitations)[#Large Language Models](/blog/tags/large-language-models)[#Machine Learning](/blog/tags/machine-learning)+5 tags [read more](/blog/post/ai-is-not-real) 6 related posts