If you’re a junior developer on your first project, you’ll likely encounter a variety of technology acronyms, italicizations and abbreviations you’ve never heard before.
Is the confusing term you just heard, something everyone’s expected to know? That can be an intimidating situation. Moreover, it can be embarrassing for a junior dev to ask for clarification on what a software abbreviation or technical acronym means.
Software technology acronyms
To help alleviate some embarrassment on the first software development project, here are explanations of the meaning of several specialized acronyms:
- KISS
- YAGNI
- TAGRI
- DRY
- WET
- POC
- MVP
- ORM
- OBOE
- POS
- SOLID
KISS: Keep it simple, stupid
This technology acronym actually means: Keep it simple, stupid .
Don’t worry, the particular term is (almost always) said in jest. Despite the use associated with the word stupid , this programming acronym is not intended as an insult.
Inexperienced developers often overdesign a system and deliver an increment of work that will be far more complicated than this needs to be. In such cases, it would be better for them to use the KISS method, and keep it simple .
YAGNI: You ain’t gonna need it
It’s difficult for a developer in order to write code and not envision multiple, optional, ways to reuse that program code in the particular future.
This can lead the developer to add methods, functions and constructors that aren’t required today, but possibly needed in the future.
That’s a bad practice. Do not write methods or features you think you might need someday. This is a waste of time, because more often than not you ain’t gonna require it (YAGNI).
TAGRI: They ain’t going to read it
When the manager asks a person to function some overtime to write some in-depth documentation, you can hit them with this technical acronym.
The production of superfluous documentation for users can be a genuine waste of your time, because the particular reality is they ain’t likely to read this (TAGRI).
DRY OUT: Don’t repeat yourself
Don’t copy plus paste code, and don’t create a bunch of functions that do essentially the same thing.
Write code that is concise, reusable, modular and abstract enough that it can be called in several places throughout your program.
Keep your program code DRY. Do not repeat yourself .
https://twitter.com/scrumtuous/status/1597034850682290177?s=20&t=tGgcu8ab3aXpjcdMZ6kaEg
WET: Create everything twice
Abstraction is usually often used to implement the DRY principle.
Unfortunately, poorly implemented abstractions added early into the particular codebase may cause serious headaches when changes must be made within the future.
Some software architects like to become WET before they are DRY. In other words, encourage developers to write everything twice until the codebase is established, and the benefit of using abstractions is completely clear.
SOLID: Object-oriented software best practices
The SOLID acronym refers to the following five, object-oriented software advancement principles plus best methods:
- Single-responsibility;
- Open-closed;
- Liskov substitution;
- Interface segregation; and
- Dependency inversion.
Enforce these principles, and your applications will be more reliable and more easily maintained.
SOLID is a commonly used specialized acronym that software designers use in order to describe best practices.
ORM: Object relational mapping
It can be difficult to map object-oriented code in a Java program to tables and records in the database.
To alleviate the object-relational impedance mismatch, many database driven applications rely on object relational mapping plus use a good ORM tool such as Hibernate, JPA or Toplink to bridge the particular gap.
OBOE: Off by one error
Also known as a fencepost mistake , an off-by-one-error (OBOE) occurs whenever conditional logic within a loop uses a less-than operator, or even <, rather than the less-than-and-equal-to operator, or ≤.
This causes a loop to either exit one iteration too early, or leave one iteration too soon — thus, the reference to the off-by-one-error .
POC: Proof of concept
A proof associated with concept (POC) provides a working piece of software that will proves a good idea or a vision is definitely feasible.
The POC only needs in order to implement happy-path programming, which essentially means tightly controlled code intended to achieve desired functionality with no errors. There is simply no need for any polished UI. At this stage, the particular app won’t be launched at customers.
A POC is simply used internally to prove that a given idea or product is doable.
A POC is an italicization of the words proof of concept .
MVP: Minimal viable product
In sports, an MVP is the most valuable player for a team or league.
In software program development, however , MVP is the minimal viable product you can deliver to customers in an initial release. It provides only the core features an application needs to satisfy user requirements. It also should be bug-free and look polished.
An MVP release has a much higher quality and features standard than a POC.
POS: Point of sale
You’ve likely run into this acronym outside of the technical world.
It has a different meaning with regard to software programmers employed in the retail industry.
Point of sale machines are essentially cash registers, although the phrase can apply to any cell phone, mobile or even embedded device that can handle product payments.
Acronyms, italicizations and abbreviations
Hopefully this particular list of eleven technology acronyms commonly noticed around software development projects will help you better understand the conversations you have along with developers and product owners in your daily scrums plus standup meetings.