Thu. Feb 9th, 2023

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:

  1. KISS
  2. YAGNI
  3. TAGRI
  4. DRY
  5. WET
  6. POC
  7. MVP
  8. ORM
  9. OBOE
  10. POS
  11. 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 technical acronym

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.

POC Proof of Concept

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.

By Wired

Leave a Reply

Your email address will not be published. Required fields are marked *