Tech terms I’ve been learning recently
There are some things as a “sorta” technical person that don’t come easy; one is knowing different software development terms. When you’re in tech, you usually hear a lot of terms thrown around, so I already knew a lot of terms about the product development lifecycle.
But then there are some specific terms that I didn’t really know or understand at first glance because they get a little too technical. But, as someone who loves to learn, I personally don’t let that stop me. And I don’t think it’s really that jarring to understand once you talk through it with a developer.
As I have been writing posts that are dedicated to product sense, I have also been working on my skills in a web development environment. Here’s some new stuff I’ve been picking up lately that I figured I’d share with you that devs say a lot that I personally had to get a little bit used to.
If you’re in the same position as me, though, of learning some new things, I suggest writing down a list of terms that you need to jog your memory on when talking with developers so you can speak their language.
Note: A lot of these terms are not for beginners. So, I don’t cover basic things like ‘epic’ or ‘user story.’
Version Control:
Definition: The management of changes to documents, code, or any collection of information, allowing teams to track modifications and collaborate seamlessly. Popular version control systems include Git and SVN.
Git:
Definition: A widely-used distributed version control system that allows multiple developers to collaborate on projects and track changes to the source code.
User Acceptance Testing (UAT):
Definition: The final phase of testing where end-users evaluate the product to ensure it meets their requirements before being deployed.
Continuous Integration (CI):
Definition: A development practice where code changes are automatically tested and integrated into the shared repository multiple times a day, promoting early detection of issues.
Continuous Deployment (CD):
Definition: An extension of continuous integration where code changes that pass automated testing are automatically deployed to the production environment.
DevOps:
Definition: A set of practices that combines software development (Dev) and IT operations (Ops), aiming to shorten the development lifecycle and deliver high-quality software.
Feature Driven Development (FDD):
Definition: A model-driven software development methodology that focuses on designing features based on the requirements of end-users.
Middleware:
Definition: Software that acts as an intermediary layer between different applications or software components, enabling communication and data management.
Refactoring:
Definition: The process of restructuring existing code without changing its external behavior to improve its readability, maintainability, or performance.
Dependency:
Definition: A relationship between two software components where the functionality of one component relies on the other. Managing dependencies is crucial for project stability.
ERD (Entity-Relationship Diagram):
Definition: A visual representation of the relationships between different entities (or tables) in a database, aiding in database design and understanding.
Caching:
Definition: The temporary storage of frequently accessed data to improve the speed and efficiency of applications by reducing the need to fetch the data from the original source.
Cloud Computing:
Definition: The delivery of computing services, including storage, processing power, and databases, over the internet. Cloud computing eliminates the need for on-site infrastructure.
Firewalls:
Definition: Security systems that monitor and control incoming and outgoing network traffic, acting as a barrier between a trusted internal network and untrusted external networks.
Routers:
Definition: Devices that forward data packets between computer networks, ensuring that information is efficiently and securely transferred between devices.
Data Architecture and Structures:
Definition: The organization and arrangement of data, including databases, schemas, and data models, to optimize data storage, retrieval, and processing.
Data Modeling:
Definition: The process of creating a visual representation (model) of data and its relationships to understand, define, and communicate how data is organized.
Web Apps:
Definition: Applications that are accessed and interacted with through a web browser over the internet. Web apps do not require installation on a user's device.
Native Apps:
Definition: Applications developed for a specific platform (e.g., iOS or Android) using platform-specific programming languages. Native apps often provide optimized performance and user experiences.
Deployment:
Definition: The process of releasing and making a software application available for use, typically involving the installation of the application on servers or cloud environments.
Push:
Definition: The mechanism by which updates or notifications are sent from a server to a user's device without a specific request from the user.
Commit:
Definition: A specific version of changes made to a codebase that is recorded in a version control system. Committing changes is a fundamental part of the development process.
Repository:
Definition: A storage location where versioned files and their history are kept, allowing collaboration and tracking changes made to the codebase.
Front-end and Backend Tooling:
Definition: Tools and technologies used in the development of the user interface (front-end) and server-side logic (backend) of an application, respectively.
SDK
Definition: A standard development kit (SDK) is a collection of software tools that facilitate the creation of a software application. For example, if you want to create a Java app, you’d need to install the Java SDK. This will provide you with the compiler, debugger, and any other software packages needed to run Java code.
To re-use code or not re-use code
Food for thought: If a piece of code is modular, well-documented, and designed for easy integration, it's a strong candidate for reuse. This promotes maintainability and reduces the risk of introducing errors when integrating the code into different projects. When a specific functionality or logic is required in multiple parts of a project or across different projects, code reuse can save time and effort. Implementing and maintaining a single version of the code ensures consistency. But, if a piece of code is tailored specifically to the unique requirements of a single project and is unlikely to be applicable elsewhere, it might not be suitable for reuse. Code designed for a specific context may not align well with other projects. Or In cases where performance is a critical factor, reusing generic code might not be optimal. Tailoring code to the specific needs of a project can sometimes lead to more efficient solutions than using a generic, reusable component. OR, even worse, the documentation isn’t there at all and it’s hard to track the reasoning behind it.
Conclusion:
With this expanded toolkit of software development terms, product managers are poised to navigate the intricacies of product development with increased confidence and clarity. Whether discussing database structures, deployment strategies, or collaborating with developers on front-end and backend tooling, a solid understanding of these terms enhances your ability to lead and contribute to successful product outcomes.
For me, what’s been helping is really just using common sense and weighing out the pros-and-cons of development when things come up. I’ve also learned that there should be a few rules of thumb you should keep because it will help guide you to make decisions faster for your team that’s relying on you to do so.
So, do I think that you need to be super versed in being technical? No, actually not really, but you should know how to speak the language and translate it, too if you really want to make the impact you desire.
Keep this cheatsheet handy, and watch as your proficiency in software development concepts transforms your product management journey.
