Code

IT terms used in the programming community

IT terms used in the programming community

Where to start your journey in IT? Get a detailed guide in our Telegram channel for free! Click on the banner and go to the channel - you will find the guide in the pin.

Find out more

About The author

The author of this content is an experienced specialist in their field, possessing deep knowledge and many years of experience. They strive to share quality information based on facts and research. In their articles, the author covers current topics, provides useful tips and recommendations, which makes their content valuable to readers. With their professional approach and attention to detail, the author creates materials that help people make informed decisions and expand their horizons.

One of the leading authors on the Medium platform, they share their thoughts on technology, lifestyle, personal experience, and other relevant topics. Their articles attract readers due to the depth of analysis and relevance of the information.

Information sources play a key role in obtaining accurate and reliable data. They can range from scientific research and articles to news publications and blogs. Quality sources help form an informed opinion and provide a basis for decision making. It is important to be able to distinguish reliable sources from unreliable ones to avoid the spread of false information. Using trusted sources promotes a deeper understanding of the topic and allows you to create high-quality content. In today's environment, when information is available in vast quantities, critical thinking and the ability to analyze sources are becoming essential skills for everyone. KISS, SOLID, YAGNI, and Other Useful Acronyms There are many acronyms in the programming world that help developers create better and more efficient code. One of the most famous is KISS, which stands for "Keep It Simple, Stupid." This principle emphasizes the importance of simplicity in development, avoiding unnecessary complexity and making code easier to maintain. Another important acronym is SOLID, which includes five principles of object-oriented design. These principles help developers create more flexible and maintainable systems. They include: single responsibility, open for extension and closed for modification, the Liskov Substitution Principle, the Interface Segregation Principle, and the Dependency Inversion Principle.

YAGNI, which stands for "You Aren't Gonna Need It," reminds programmers not to add functionality that is not currently required. This principle helps avoid unnecessary work and increases focus on the tasks at hand.

These acronyms not only help developers improve the quality of their code but also promote more effective teamwork. Understanding and applying these principles allows you to create software that is easy to maintain and develop.

A translator is a specialist who translates text from one language to another. In the modern world, where globalization and international communication are becoming increasingly relevant, the role of a translator is significantly increasing. Professional translators ensure the accuracy and appropriateness of information, taking into account cultural and linguistic nuances. Translation services are essential in various fields, including business, education, science, and the arts. High-quality translation facilitates effective interaction between people and organizations, which is especially crucial in an international environment. It is important to choose a qualified translator who not only speaks languages ​​but also understands the specifics of the subject area.

Ruslan Gadzhiev is an expert in his field, possessing deep knowledge and experience. His professional skills span various aspects, allowing him to effectively solve problems and achieve results. Ruslan actively shares his knowledge by conducting seminars and master classes, thereby contributing to the development of the industry. His approach to work is based on the analysis and application of modern methodologies, which ensures the high quality of his projects. Ruslan Gadzhiev is a reliable partner and a source of valuable information for anyone striving for professional growth.

Over 17 years of working in the industry, I have encountered many abbreviations – both serious and funny. Developers certainly appreciate abbreviations. Some of them simplify communication, like MVP or PoC, which clearly require little effort to create. Others have interesting sounds, like SOLID, DRY, and KISS. These terms not only make communication more effective but also become part of the professional developer culture, emphasizing important principles and approaches in software development.

There are many acronyms in the development world, and I have prepared a brief overview of the most popular, as well as a few lesser-known ones. This will help you refresh your memory of their meaning.

DRY

Let's start with a fundamental development principle that you have probably encountered more than once. DRY, which means "dry" in English, stands for "Don't Repeat Yourself." This principle is key to optimizing code and increasing its readability. By following this principle, developers avoid duplicating information, which contributes to more efficient project management and simplifies the change process. Applying the DRY principle not only reduces the amount of code but also minimizes the likelihood of errors, which in turn improves the quality of the final product.

When writing code, it's important to consider the reusability of individual fragments. Try to separate common logical blocks into universal functions or classes, and create modules that can be used in different parts of your project. This isn't about creating a library for every function you use once, but rather about separating similar logic found in multiple places into separate functions. If the same function is repeated in different parts of the code, it makes sense to move it into a common module. Finally, if a module is used repeatedly, it might be worth considering turning it into a full-fledged library. This will not only improve the readability of your code but also make it easier to maintain and develop.

You see, it's important to avoid repetition. This is a key rule that helps create clear and structured content. By following this principle, you can improve the quality of your text and make it more informative. You need to find new ways to express your thoughts to keep readers interested and provide them with valuable information. Effective use of language and variety of wording will help avoid unnecessary repetition and make your text more engaging.

This principle is relevant for all platforms and programming languages. If you need to automate certain behavior, avoid rewriting the same logic. Instead, generalize it and move it to a separate component. This will not only help reduce the amount of code but also improve its readability and maintainability. Using this approach contributes to the creation of more efficient and modular software solutions.

The DRY (Don't Repeat Yourself) principle can be successfully applied not only within a single repository. To simplify access to modules or components when working with multiple repositories, we recommend using Bit. This tool allows you to conveniently manage shared components and modules, supporting technologies such as Node.js, TypeScript, React, Vue.js, and Angular. Bit significantly optimizes the development process, ensuring code reuse and improving collaboration between teams.

An example of reusing React components with bit.dev Screenshot: Bit.dev / Skillbox Media

KISS

The acronym KISS (Keep it simple, stupid) has always resonated with me thanks to its brevity and meaning. It calls for simplicity in solutions and approaches. An alternative interpretation—Keep it stupid simple—captures the essence of this idea even more vividly, emphasizing the importance of minimalism and accessibility in the development and communication process. Applying the KISS principle helps avoid unnecessary complexity and makes the results more understandable and effective.

When solving various problems, you can sometimes get so carried away that you don't notice how you're overengineering. As I like to say, it's like shooting sparrows with a cannon. Ultimately, the problem will be solved, but it could have been accomplished much more simply and elegantly. Optimizing processes and simplifying approaches to problems allows you to save not only time but also resources, which is more beneficial in the long run. It's important to remember that the effectiveness of a problem often lies in simplicity and a reasonable approach.

I agree that there are situations where the simplicity of code or architecture can lead to inefficiency. In such cases, it is necessary to introduce additional elements of complexity into the logic. However, you should always ask yourself whether you adhere to the KISS (Keep It Simple, Stupid) principle. This principle helps avoid unnecessary complexity and keep the code clean and understandable, which in turn contributes to better maintainability and scalability of projects.

Make sure your logical chains are sufficiently clear. Check if your colleagues have sufficient knowledge to understand them. Simple code and a concise design minimize the risk of errors and make them easier to read. Remember the KISS (Keep It Simple, Stupid) principle, which emphasizes the importance of simplicity in development. Simplicity in code and design promotes more effective team collaboration and reduces the likelihood of misunderstandings.

SOLID

This is another important programming rule. It implies the following:

  • Single responsibility principle.
  • Open-closed principle.
  • Liskov substitution principle.
  • Interface segregation principle.
  • Dependency inversion principle.

These are five different principles combined into one (solid). Let's take a closer look at each of them.

Each function in your code should be focused on performing one specific task. This makes the code easier to read and maintain, and promotes reuse. By following this principle, you improve the structure of your software and make it more understandable for other developers. Clear specialization of functions makes it easier to identify and fix bugs, as well as adapt code to new requirements.

If you're familiar with *NIX systems, such as Linux distributions and macOS, you've probably used the terminal and commands like ls and cd. These commands strictly adhere to the Single Responsibility Principle (SRP) and are designed to perform specific tasks, such as changing directories or listing their contents. In *NIX systems, there are no utilities that perform multiple tasks simultaneously, consistent with the UNIX-way philosophy. This approach ensures simplicity, flexibility, and high performance, allowing users to combine commands to achieve the desired result.

To ensure single responsibility, functions should be simple and straightforward. When more complex behavior is required, the inputs and outputs of multiple functions should be combined, creating a composition. This keeps the code clean and easier to maintain, while still providing the required functionality. Proper organization of functions improves the readability and maintainability of code.

The Single Responsibility Principle (SRP) applies not only to functions but to software architecture as a whole. For example, using microservices instead of one large mega-module significantly simplifies system maintenance and evolution. Each microservice performs its own narrow task, which makes the code more structured and understandable. This also applies to functions: simple and clear functions are easier to maintain, read, understand, and write. By following the SRP principle, you create a more resilient and scalable architecture, which ultimately has a positive impact on the quality of the software and its future evolution.

If you need a function getUserAndRelatedBooks that performs two tasks, consider splitting it into two separate functions: getUser and getUsersBooks. In this case, getUsersBooks will accept the result of getUser as input. This approach will allow you to efficiently implement getUserAndRelatedBooks using function composition, making the code cleaner and more maintainable.

The text discusses an important software development principle that modules or libraries should be open for extension but closed for modification. This means that developers can add new behavior or functionality without changing the source code. This approach avoids the problems associated with modifying other people's modules, which can lead to bugs and difficulties in maintenance. Applying this principle contributes to more robust and flexible code, which is especially relevant in modern projects.

If you find yourself needing to modify your code to add new functionality or modify existing functionality, you have violated the open-closed principle. This principle states that software entities should be open for extension but closed for modification. This is an important aspect of development that helps maintain clean and robust code. By following this principle, you can improve the structure of your application and simplify its scaling and updating processes.

The code shown demonstrates a violation of the flexibility principle. If you need to add a new city, you'll need to manually edit the file and modify the knownCities array. This can lead to errors and increase data update time. For more efficient city management, consider using an external data source or database to simplify the process of adding and editing city information.

Screenshot: Skillbox Media

There are several ways to solve this problem while respecting the principles of openness and closure. One approach is to use interfaces that allow the system's functionality to be extended without changing existing code. This allows for the addition of new features without affecting existing components. It is also important to implement clear and understandable architectural solutions that facilitate easy modification and maintenance of the system. This way, you can achieve the necessary balance between stability and adaptability, which is a key aspect in software development.

Screenshot: Skillbox Media

The addValidCity method allows you to modify the code's functionality to meet specific requirements without changing the source file. This simplifies the process of software development and adaptation, providing the ability to integrate new cities into the system without having to make changes to the main code. Using this method makes the code more flexible and manageable, which is especially important for project maintenance and development.

The substitution principle, also known as LSP (Liskov Substitution Principle), plays a key role in programming theory. Its basic essence is that objects of a subclass should be interchangeable with objects of a superclass without changing the correctness of the program. This means that if a program uses an object of a superclass, it can be safely replaced with an object of a subclass without causing errors or incorrect behavior. Understanding and applying LSP contributes to more robust and maintainable code, which is an important aspect of software development.

Functions that work with pointers or references to base classes should be able to accept subtypes of that base type without requiring knowledge of the existence of those subtypes. This allows for code flexibility and extensibility, facilitating the use of polymorphism, which is an important aspect of object-oriented programming.

In this context, it is clear that we are dealing with the fundamentals of object-oriented programming (OOP). OOP principles allow for the effective use of inheritance where appropriate and the use of alternative approaches when inheritance is inappropriate. This provides greater flexibility in software development and contributes to the creation of more robust and maintainable systems. Proper application of OOP principles helps avoid code redundancy and improves its readability, which ultimately improves the quality of the final product.

Let's consider this example. In geometry, a square is a specific type of rectangle. It's essentially a rectangle with equal width and length. If we try to model this object using code, we might get the following result:

Screenshot: Skillbox Media

The setWidth and setHeight methods are not functional in this context because they do not provide the ability to transform a rectangle into a square. This violates the Liskov Substitution Principle, which states that subclass objects should be replaceable with base class objects without changing the desired properties of the program. Therefore, using these methods in their current form does not meet the expected results, making them ineffective in the context of software development.

LSP, or the Liskov Substitution Principle, ensures the correct use of inheritance in your code. Despite its potential complexity, it is important to consider this principle when designing classes. Proper adherence to LSP helps avoid errors and improves code quality, making it more flexible and understandable.

In this context, it is important to understand that forcing programmers to use unnecessary methods in their code can lead to poor development quality. An interface is an interaction between classes, consisting of a set of methods that must be implemented. When creating interfaces, for example in TypeScript, you should carefully evaluate which methods users actually need. Avoid creating overloaded interfaces with redundant functionality. The divide-and-conquer principle is key when designing interfaces, as it leads to cleaner, more maintainable, and more understandable code. By considering these aspects, you can improve the experience of programmers and increase the efficiency of development.

Screenshot: Skillbox Media

In this code, we see the implementation of methods for the module MyModule. While some users may want to add the close and open methods, it's important to note that unless your task requires compatibility with Internet Explorer 8, the last method listed in the code may be redundant. Optimizing your code can improve performance and make it easier to maintain, so it's important to carefully consider which features to implement based on the actual needs of your project.

The Interface Segregation Principle applies to software design. Following this principle, it's important to clearly separate methods, giving users the ability to independently choose which ones to use and for what tasks. This promotes more flexible and efficient work with the interface and improves the user experience by allowing functionality to be tailored to specific needs.

The Dependency Inversion Principle completes the SOLID concept. This principle emphasizes the importance of separating abstractions from concrete implementations, which helps reduce component coupling and improve system flexibility. Dependency inversion contributes to more robust and scalable code, a key aspect of modern programming. Dependency injection allows for easy replacement and testing of components, which in turn improves the overall structure and maintainability of software.

The classic form is as follows:

  • High-level modules should not import entities from lower-level modules. Both types of modules should depend on abstractions.
  • Abstractions should not depend on details. Details should depend on abstractions.

This tool is indispensable in various scenarios, especially in unit testing. When testing code that depends on third-party libraries, injecting a mock of that library allows you to control the behavior of the code under test. Let's look at this with an example:

Screenshot: Skillbox Media

In this example, we observe that the connection to the database is made and declared inside single module, while the saveUser function is exported for use in other parts of the application. If you attempt to test this code, the saveUser function will automatically attempt to perform its primary task—connecting to the database and saving user information. This highlights the importance of proper code organization and dependency management when working with databases in modern applications. By enabling dependency injection and using the database connection as the second parameter, you can continue to inject mock objects. This allows for more flexible testing management and improves component isolation, which in turn leads to more reliable and maintainable code. Mock injection allows you to effectively simulate the behavior of dependencies, which simplifies the testing process and allows developers to focus on the application logic without worrying about external resources.

Screenshot: Skillbox Media

It is now possible to switch dependencies, for example, use an alternative module for connecting to a database. This will not affect the code, which will continue to execute the necessary logic without changes. This approach provides flexibility and simplifies the process of integrating various system components, which makes development more efficient and resilient to change.

Dependency injection is a powerful tool for creating extensible designs. This approach is especially important for developers seeking to ensure the flexibility and scalability of their applications. Using dependency injection makes it easy to manage components and their interactions, which in turn simplifies testing and modifying code. It is recommended to consider dependency injection during the development process to improve the quality and efficiency of the created software.

YAGNI

The principle, known as «You ain’t gonna need it», originates from extreme programming. He argues that functionality should be developed only when truly needed. This approach helps avoid redundancy and focus on creating high-quality code that meets the current requirements of the project. Applying this principle helps optimize development and improve productivity, as it allows teams to focus on important tasks and minimize the risk of technical debt.

Agile methodologies focus on the current project iteration. Working ahead of the curve, adding functionality that is not currently needed, is not an optimal approach. This is because plans can change very quickly, and unnecessary features can distract the team from completing relevant tasks. The core principle of Agile is flexibility and adaptability, which helps teams successfully respond to changes and ensure a high-quality product.

When I talk about changing plans, I mean the flexibility of the Agile approach. Iterations in Agile are usually short, which allows for feedback early in the development process. This feedback can significantly change the direction of the entire project. Why waste time developing features that will ultimately prove unnecessary? It is important to adapt and adjust the course of work based on the actual needs of users and changes in the project. This approach not only saves time but also improves the quality of the final product.

It is important to note that when using waterfall development methods, where all stages of work are planned in advance and participants strictly follow the established plan, the YAGNI principle is not applicable. In such cases, the emphasis is on detailed design and the implementation of predefined tasks, which makes the YAGNI approach less relevant.

BDUF

When discussing the waterfall development model, it is important to mention the Big Design Up Front principle, which is completely consistent with it. This principle assumes that the main time allocated for the design of an application is not spent writing code, but is focused on careful planning and elaboration of the architecture. This approach allows you to define all key aspects of the project in advance, minimizing risks and ensuring more effective management of the development process. Ultimately, this contributes to the creation of a higher-quality and more sustainable software product.

The waterfall development model involves careful planning of all project stages. This helps minimize the time spent identifying and correcting defects in the future. The main idea is to take into account all details and requirements in advance, which contributes to a more efficient development process and improves the quality of the final product.

BDUF, or Big Design Up Front, has its detractors, especially among supporters of agile methodologies. These critics believe that in the era when Agile has become the dominant approach, BDUF has lost its relevance and usefulness. From their point of view, the rigid structure offered by BDUF does not meet the requirements of a rapidly changing market and the flexibility necessary for successful project execution. Adherents of Agile argue that an iterative approach allows for faster response to changes and better consideration of user needs.

SoC

The principle of separation of concerns is one of the key aspects in software design. I actively apply this principle both in platform development and when creating internal project architecture. It allows for the separation of functional areas, which simplifies system maintenance and scaling. Using this approach improves code quality and reduces complexity, which makes development more efficient.

The Separation of Concerns (SoC) principle should not be confused with the aforementioned Single Responsibility Principle. The SoC principle encourages the organization of functions or modules into separate services. When designing a multifunctional system, which is a common practice, functions can be grouped into modules based on the tasks they perform. This improves the code structure, increases its readability, and simplifies future maintenance and scaling of the system.

A blogging platform that allows users to publish articles is a powerful tool for information sharing. A single system on such a platform can effectively handle various tasks, including user management, posting, and data analysis. However, by applying the Separation of Concerns (SoC) principle, more optimal results can be achieved. This allows you to create an architecture in which various system components can specialize in individual tasks, which increases productivity and simplifies further support and development of the platform.

Infographics: Maya Malgina for Skillbox Media

This architecture concept involves dividing responsibilities into modules. This results in a higher degree of organization and flexibility. Each module is responsible for its own specific function, which facilitates the development, testing, and maintenance of the system. This approach improves scalability and simplifies making changes, since changes in one module minimally affect the others. Ultimately, an architecture based on modularity allows for the creation of more reliable and adaptive solutions.

  • You get scalability for each block of functionality. Now, if necessary, you can easily scale the same user management module — for example, because it is pulling too much traffic, while the rest of the platform remains unloaded.
  • Changes become easier: the coupling of code elements is loosened, and you can, for example, almost completely rewrite the post management module without affecting other sections.
  • The platform becomes more stable. If one of the modules breaks, the system can potentially remain operational. With less functionality, of course, but it is still possible.

SoC, or the separation of concerns principle, is actively used in the development of APIs, library architectures, and other software solutions. Its main idea is to organize functions in a logical way so that they are grouped together, which simplifies their use and improves the interaction for end users. The use of SoC allows developers to create more flexible and maintainable systems, which contributes to increased development efficiency and a reduced likelihood of errors.

MVP

Various acronyms are often encountered in the field of programming and software development. One of these is MVP, which stands for Minimum Viable Product. This concept implies the creation of a product with a minimum necessary set of functions, allowing its functionality to be tested in real conditions and the level of user satisfaction to be assessed. MVP plays a key role in the development process, as it helps teams quickly get feedback and make necessary improvements, which ultimately leads to a more effective and successful product launch.

This method is widely used to determine the feasibility of product development. Thanks to the minimum viable product (MVP) concept, the target audience has the opportunity to test the product and provide feedback. This allows developers to understand whether it is worth continuing to invest time and resources in further development. MVP helps reduce risks and better tailor the product to user needs.

PoC

Proof of Concept (proof of concept) and MVP (minimum viable product) play a key role in the development process. Unlike MVP, which requires careful planning and significant financial investments, Proof of Concept is a more simplified version. It is used in the early stages of development and serves to test the viability of an idea or concept. The main goal of a Proof of Concept is to prove or disprove the need for a certain functionality, thereby avoiding unnecessary costs for further development. Thus, a Proof of Concept becomes an essential tool for entrepreneurs and developers, allowing them to effectively evaluate the market and adapt to user requirements.

Essentially, a Proof of Concept (PoC) is a temporary code that serves to demonstrate the concept of a project, rather than its final implementation. While in some cases it is possible to integrate a PoC into a real product, it is important to understand that proving a single idea may require creating several PoCs. Spending a lot of time on all these versions in the hopes of getting a single working product is impractical. Therefore, a PoC is often created with the intention of using it only as a temporary solution, which avoids regrets if it needs to be removed.

I really like the concept of PoC, especially in the context of using it as an experimental material. It reminds me of the story of Iron Man and his first armor, the Mark I: it demonstrated its capabilities, even with only an arc reactor. Later, with the creation of the Mark II, the level of technology and functionality increased significantly. Thus, PoC serves as an excellent example for testing ideas and concepts, allowing you to evaluate potential and identify opportunities for improvement in future versions.

Conclusion

You've likely encountered all the abbreviations mentioned in this article in instructions, guides, or heard from colleagues. Now you have knowledge of what they mean and in what situations they are appropriately used. This will help you better navigate professional literature and improve your communication with colleagues. Understanding the meaning of abbreviations is important in any field, as they are often used to simplify information and save time.

Also learn:

  • How to Find a Job in IT and Digital as a Beginner
  • What is JavaScript and Why Do You Need It
  • Indentation Rules: How to Make Layout Flexible and Avoid Errors

Java Developer Profession

You will learn Java programming from scratch and create web applications using the Spring framework. In six months, you will gain fundamental skills and build a portfolio, and we will help you find a job.

Find out more