What is a Virtual Machine? 3 Types of Virtual Hostings

Anyone who decides to get into programming faces an important question: which language should they learn first? For a beginner unfamiliar with software development's nuances, trying to answer this alone can easily lead to mistakes. Choosing hastily comes with a risk, as you might fall into the sunk cost trap. You could end up picking a language that doesn't align with your desired direction, whether it's mobile development, game dev, or systems programming. Relearning another language later may render much of your time and effort wasted. So, it is of course much better to make the right decision early. And for this, you need at least a general understanding of how each language works: its specifics, features, areas of application. In this article, we’ll present both complex and beginner-friendly programming languages, to help  beginners make an informed choice. Why It’s Important to Choose the Right Programming Language There are several reasons why it's crucial to study the features of each language at the very beginning and pick the most suitable one: Task suitability. Every language has its own strengths. One might be better suited for a specific set of tasks than another. Your chosen development field heavily affects your tech stack, especially in today's world, where specialization is becoming more prominent. The days when operating systems, programs, and games were all written in one language are gone. Now, there's a tool for everything. Community support. Any popular programming language has an active community, extensive documentation, and plenty of frameworks and libraries. However, more complex languages (like C++) can be harder to work with regarding libraries and documentation. You should take this into account. Career prospects. Learning a high-demand language opens more job opportunities and makes it easier to find projects that align with your interests and specialization. Scalability and performance. Some tasks require special features from a language, like efficient memory management or support for parallel computing. Sometimes, these factors are critical. So, clearly understanding which language to start learning can help avoid many future issues, and at best, guide you into an exciting direction and a successful developer career. Python: The Best Starting Point Python is a high-level, interpreted programming language with dynamic typing. Dynamic typing means the variable type is determined at runtime and can change. This adds flexibility but increases the chance of errors. Static typing means a variable's type is set at compile time and can't change. Type errors are caught earlier. For example, in a dynamically typed language, you could first assign the number 7 to a variable and later assign a string like "Hello, World" to that same variable. In a statically typed language, this would cause a compile-time error. Interpreted languages execute code directly without first converting it to machine code. Compiled languages, on the other hand, convert high-level code into machine instructions, making them generally faster. Python was initially created by Dutch programmer Guido van Rossum in 1991. Today, it is maintained by the global Python Steering Council and the nonprofit Python Software Foundation. Simple Syntax Python’s key feature is its use of indentation and colons instead of curly braces to define code blocks: if True: print("One block of code") else: print("Another block of code") This simplifies the language and makes the code more visually readable, especially in Object-Oriented Programming: class Butler: def __init__(self, name): self.name = name def hello(self): print(f"The butler of this mansion welcomes you — {self.name}!") butler = Butler("Alfred") butler.hello() # Output: The butler of this mansion welcomes you — Alfred Python aims to be both clear and functional, using as few syntax elements as possible (like braces or semicolons). Versatile Applications Thanks to its clean syntax and line-by-line execution, Python can be used in a wide variety of fields: Web Development. Building the backend of web apps, handling user requests (RESTful APIs), and generating dynamic web pages. Machine Learning. Processing and analyzing large datasets, building ML models, and creating neural networks. It’s also widely used in scientific computing across physics, biology, and engineering. Automation. As a scripting language, Python is used to automate routine tasks, manage servers, and streamline DevOps workflows. Despite its power and use in large-scale infrastructure and serious applications, Python remains the most beginner-friendly programming language. Large Community and Documentation Python is used globally across industries and research, resulting in a massive community of developers, engineers, and scientists. Regular conferences like PyCon, EuroPython, and PyData foster idea-sharing and collaboration. Online platforms like StackOverflow and Reddit host extensive discussions on Python coding nuances. The official documentation provides detailed language syntax, standard libraries, and step-by-step guides with examples, covering even the most basic topics. JavaScript: The Language of Web Development JavaScript is a high-level, interpreted programming language with dynamic typing. It was developed in 1995 by Brendan Eich at Netscape. Its name's similarity to Java was a marketing decision rather than a technical one. Java was extremely popular at the time, and the name helped boost interest in the new language. The Core of Frontend Development Modern browsers come with a built-in JavaScript engine to run scripts that manipulate the DOM (Document Object Model) to dynamically change a web page’s content: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>DOM Manipulation</title> </head> <body> <div id="container"> <p>This is the original text.</p> </div> <button id="changeBtn">Change Content</button> <script> const container = document.getElementById('container'); const button = document.getElementById('changeBtn'); button.addEventListener('click', function() { const firstParagraph = container.querySelector('p'); firstParagraph.textContent = "Text changed!"; const newParagraph = document.createElement('p'); newParagraph.textContent = "A new paragraph was added to the DOM."; container.appendChild(newParagraph); }); </script> </body> </html> Thanks to JavaScript, developers can create interactive UIs for modern web apps. Scripts run directly in any browser, so no extra software is needed. This makes JavaScript one of the most accessible programming languages for beginners. A Rich Ecosystem Web development with JavaScript is a whole industry on its own. There are countless libraries and frameworks for managing web app states, such as React and Vue. But JavaScript isn’t limited to the client side. With Node.js, JavaScript can also run on servers. That's why many JavaScript applications and libraries are isomorphic, meaning they work both on the front and backend. Because of this flexibility, JavaScript is a solid first programming language, helping you become a Full Stack developer (handling both frontend and backend). Java: Stability and Demand Java is a high-level, object-oriented programming language with static typing. It was developed in 1995 by Sun Microsystems (later acquired by Oracle), led by James Gosling. Java is a compiled language. Its source code is compiled into intermediate bytecode, which is executed by the Java Virtual Machine (JVM). Since JVMs are implemented for different operating systems, Java code is cross-platform and can run on any OS without recompilation. That’s why Java’s slogan is: "Write once, run anywhere." Android Development Android is an OS with many components written in different languages. While its kernel is in C and C++, app development libraries and APIs are Java-based. This has made Java almost synonymous with mobile development, including both apps and games. For example, the popular game Minecraft was written in Java and, almost immediately after its PC release in 2011, was added to the Google Play Market as a mobile version for Android. High Performance Unlike interpreted programming languages, Java uses JIT (Just-in-Time) compilation. When an application is run, the bytecode is dynamically compiled into machine code so that frequently used code segments are optimized on the fly. On one hand, Java delivers higher performance than interpreted languages, such as JavaScript or Python. On the other hand, the indirect execution of bytecode is slower than direct execution of machine instructions in compiled languages like C or C++. Java is quite a fast language, especially considering that it runs through a virtual machine to provide strong cross-platform compatibility. Popularity in the Corporate Environment Cross-platform capabilities, application portability, predictable behavior, stability, and security are key reasons why many companies prefer Java. And of course, its rich ecosystem—libraries, frameworks, and tools—all contribute to simplifying and accelerating enterprise application development, maintenance, and updating. In contrast to Python, Java uses a strict C-like syntax: public class Greeter { private String name; // Constructor that takes a name for greeting public Greeter(String name) { this.name = name; } // Method that prints the greeting to the console public void greet() { System.out.println("Hello, " + name + "!"); } public static void main(String[] args) { // If a command-line argument is provided, use it as the name. Otherwise, default to "World" String name = (args.length > 0) ? args[0] : "World"; Greeter greeter = new Greeter(name); greeter.greet(); } } C#: A Windows Developer's Alternative C# is a high-level, object-oriented programming language with static typing. However, dynamic typing is also possible using the dynamic keyword. The C# programming language first appeared in 2002. It was created by Microsoft under the leadership of engineer Anders Hejlsberg.  Like Java, C# code is not compiled directly into machine instructions but into an intermediate representation called CIL (Common Intermediate Language) or simply IL. During program execution, the CIL code is converted via JIT compilation into native machine code optimized for the target platform. Used in .NET Development and Unity .NET is a development platform created by Microsoft for building portable applications. It can be used to develop websites, mobile apps, games, neural networks, and cloud services. The .NET ecosystem includes: Programming languages (C#, F#, VB.NET) Libraries and frameworks (for databases, servers, graphics) Runtimes C# is the main language in the .NET ecosystem. To some extent, Java and .NET can be seen as similar ecosystems. In Java, apps run on the JVM (Java Virtual Machine), while in .NET, they run on the CLR (Common Language Runtime). In both cases, code is compiled to bytecode, which is then executed on a virtual machine. Moreover, Java and C# have syntactic similarities, as both are C-style languages. Naturally, game development has also embraced C#. For instance, the popular Unity game engine uses C# as the primary scripting language for creating gameplay mechanics and scenarios. Strong Microsoft Support Microsoft plays a key role in the development of C#. This support includes the language itself, tooling, libraries, and infrastructure. C# integrates well with other Microsoft products and is tailored to the Microsoft ecosystem, although it remains cross-platform. For example, the Visual Studio IDE is best optimized for the C# compiler. A simple C# console application looks like this: using System; class Program { static void Main() { Console.Write("May I have your name?: "); string name = Console.ReadLine(); Console.WriteLine($"Welcome, {name}!"); } } C and C++: For Systems Programming C and C++ are compiled programming languages that are closely related. C++ is an extended, object-oriented version of the procedural C language. C was created at Bell Labs by Dennis Ritchie in 1972, while C++ was introduced by Bjarne Stroustrup in 1983. High Performance Unlike Python, JavaScript, and Java, C and C++ do not require an interpreter or a virtual machine. Their code is compiled directly into processor instructions. In other words, these languages are as close to the hardware as possible, allowing low-level control of system resources. That’s also why these languages are considered complex—manual control and lack of automation demand high programmer skill. Memory Management C and C++ give full control over computing resources. They do not include a garbage collector that automatically frees unused memory. This reduces overhead but increases the risk of memory leaks. Due to their performance and control, C and C++ are preferred for high-load computing, like OS kernels (Linux, Windows, macOS, Android), game engines (Unreal Engine), and financial systems. In short, C and C++ remain the go-to languages when speed and efficiency are critical. Foundation for Modern Languages Originally developed for Unix-like OS development, C became the ancestor of many modern languages. Its syntax is the foundation of many popular languages: C++, Java, C#, JavaScript, Go, Swift. Example of simple C++ code using classes: #include <iostream> #include <string> class Car { private: std::string brand; public: Car(std::string carBrand) { brand = carBrand; } void showInfo() { std::cout << "Car brand: " << brand << std::endl; } }; int main() { Car myCar("Toyota"); myCar.showInfo(); return 0; } Swift: For iOS Development Swift is a modern high-level, statically typed language that is compiled into machine instructions. Apple’s Official Language Before Swift, Apple’s main language was Objective-C, dating back to the 1980s. Despite its power, it had outdated principles and lacked support for modern syntax and safe memory handling. In 2014, Apple introduced Swift, a modern, safe, and convenient language aimed at improving code writing, safety, performance, and memory management. In short, Swift was created as Apple’s new official language for iOS, macOS, watchOS, and tvOS development. Simplified Syntax Compared to Objective-C Objective-C: NSString *name = @"John"; NSInteger age = 25; NSArray *fruits = @[@"Apple", @"Banana", @"Orange"]; - (void)greet:(NSString *)name { NSLog(@"Hello, %@", name); } [self greet:@"Alice"]; Swift: let name = "John" var age = 25 let fruits = ["Apple", "Banana", "Orange"] func greet(name: String) { print("Hello, \(name)") } greet(name: "Alice") As a result, Swift has cleaner and more understandable syntax, which means faster development. A Great Choice for Mobile Development Swift is optimized for Apple’s custom chips. It’s the main language for developing native iOS applications and games. Apple actively supports and develops the Swift ecosystem, and it is fully integrated into Xcode, Apple’s official IDE. Go: A Modern Language from Google Go, or Golang, is a high-level, statically typed programming language designed with concurrency in mind. It was developed in 2007 by Google engineers Robert Griesemer, Ken Thompson, and Rob Pike. Google created Go to address speed, concurrency, and development convenience issues found in other languages, like: C++: Powerful but complex Java: Bytecode execution is slower than native Python: Simple but slow due to interpretation As a company focused on cloud services, Google made Go with server-side development in mind. Simplicity and Minimalism Go has automatic garbage collection, a simple syntax, and convenient abstractions, but it's not a classical OOP language. There are no classes, no this keyword, no method/operator overloading. Instead, Go uses structs with methods attached to them: package main import "fmt" type Person struct { Name string Age int } func (p Person) Greet() { fmt.Println("Hi, my name is", p.Name) } func main() { person := Person{Name: "Anna", Age: 35} person.Greet() } Go minimizes complexity and accelerates development by unifying syntax: No classes/inheritance: use structs and interfaces instead. No method/operator overloading: one name per method. No exceptions: use explicit error checks Exceptions are errors thrown by an application during execution that can be caught and handled by user-written code without terminating the program. At first glance, such simplification may seem to limit the programmer’s capabilities. However, in reality, a strict definition of application logic provides greater flexibility in possible implementations and solutions. This is likely why Go, along with Python and JavaScript, is considered one of the best programming languages for beginners. High Performance Go code is compiled to machine instructions. The lack of heavy features like overloading and exceptions makes Go programs high-performing. The garbage collector is optimized for minimal delays. Instead of OS level threads, Go uses goroutines—lightweight threads that use only a few kilobytes of memory and can be spawned in large numbers. Great for Server-Side Development Compiled code, concurrency support, and minimal syntax make Go ideal for backend development. Built-in packages for web servers, networking, databases, and encoding (like net/http, database/sql, encoding/json) allow out-of-the-box server app development. Which Programming Language Should You Choose First? So. When choosing a programming language, several important factors should be taken into account: Development field. In what area will you be working? Web applications, systems programming, game development? And if it’s game development, what kind? Mobile or desktop? Or maybe even console games? Future tasks. The tasks you’ll face will depend on the area of development. But the type of tasks can also vary. For example, web development includes both frontend and backend. In game development, there’s engine development and gameplay mechanics creation. Entry threshold. Depending on personal aptitudes and existing skills, learning a specific programming language will be different for every developer. For instance, effective use of C and C++ requires deeper computer science knowledge: understanding memory management, algorithm complexity, and mathematical computations. The showcased languages can be compared across several key parameters: Language Syntax Complexity Execution Model Type System Year Released Official Site Primary Field Additional Knowledge Python Low Interpretation Dynamic 1991 python.org Data Analysis Machine Learning, Big Data JavaScript Low Interpretation Dynamic 1995 - Web Development Layout, Network Protocols Java Medium Compilation Static 1995 java.com Mobile Development Android, DevOps C# Medium Compilation Static 2002 microsoft.com Desktop Development .NET C/C++ High Compilation Static 1972 / 1985 isocpp.org Systems Programming Mathematics Swift Medium Compilation Static 2014 swift.com Mobile Development macOS, iOS Go Medium Compilation Static 2012 go.dev Servers, Microservices RESTful APIs, Containerization Learning the syntax of a specific language is best done with the help of books.  You can clarify various details through tutorial articles and videos. And when problems arise during learning or work tasks, you can ask questions on platforms like StackOverflow. Ultimately, the choice always comes down to personal preference. In the long run, it’s better to pursue something you are actually interested in rather than just something profitable. Otherwise, you'll just burn out.

You can write code. You can edit existing code. You can even rewrite it from scratch. There’s a lot you can do with code. But what’s the point if the code lives in its own echo chamber? If the same person writes, views, and edits it, many critical errors can drift from one version to another unnoticed without external evaluation. Code locked within the confines of a single text editor is highly likely to stagnate, accumulating inefficient constructs and architectural decisions, even if written by an experienced developer. This is why every developer should understand what code review is, how it’s done, and what tools are needed. Presenting your code properly to others, gathering feedback, and making changes wisely is important. Only this way can code remain “fresh” and efficient, and applications based on it — secure and high-performing. Code review is the process of examining code by one or more developers to identify errors, improve quality, and increase readability. Types of Code Review 1. Formal Review A formal review is a strict code-checking process with clearly defined stages. It’s used in critical projects where errors can have serious consequences — for example, in finance or healthcare applications. The analysis covers not just the code but also the architecture, performance, and security. Reviewers often include not just developers but also testers and analysts. For example, a company developing a banking app might follow these steps: Development: A developer completes a new authentication module and submits a pull request via GitHub. Analysis: A review group (2 senior developers + 1 security specialist) is notified and checks the code for logic, readability, and security (e.g., resistance to SQL injection and XSS attacks). Discussion: Reviewers meet the developer over Zoom and give feedback. Documentation: All notes are posted in GitHub comments and tracked in Jira. For instance, some RESTful requests may be flagged as vulnerable with a recommendation to use parameterized queries. Fixes: The developer updates the code and the pull request; the cycle repeats until approval. Approval: Once reviewers are satisfied, the code is merged into the main branch. 2. Informal Review Informal code review is less strict and more flexible, usually involving: Quick code discussions in chat or meetings Showing code to a colleague in person Asking an expert a technical question This kind of review happens often in day-to-day work and is characterized by spontaneity, lack of documentation, informal reviewer choice, and shallow checks. In simpler terms, it’s more like seeking advice than a formal third-party audit. It's a form of knowledge sharing. Types include: Over-the-Shoulder Review: One developer shows their code to another in real time (via screen share, chat message, or simply turning the monitor). Ad-hoc Review: A developer sends code to a colleague asking them to check it when convenient, e.g., I wrote this handler, but there’s an error. Can you take a look? Unstructured Team Review: Code is discussed at a team meeting, casually and collaboratively, often with knowledge sharing. Feedback is given as recommendations, not mandates. Developers can ignore or reject suggestions. Although informal reviews are less reliable than formal ones, they’re quicker and easier, and often complement formal reviews. Examples of integration: Preliminary Checks: Before a pull request, a dev shows code to a colleague to discuss and fix issues. Informal Discussion During Formal Review: Reviewers may chat to resolve issues more efficiently. Quick Fixes: Developers make changes right after oral feedback instead of long comment exchanges. 3. Pair Programming Pair programming is when two developers work together on one machine: one writes code, and the other reviews it in real-time. It’s literally simultaneous coding and reviewing, which helps catch bugs early. Roles: Driver: Writes code, focused on syntax and implementation. Navigator: Reviews logic, looks for bugs, suggests improvements, and thinks ahead. Roles can be switched regularly to keep both engaged. Variants: Strong Style: Navigator makes decisions, and the driver just types. It works well if one of the developers is more experienced. Loose Pairing: Both share decision-making, swapping roles as needed. Though rare, pair programming has advantages: Instant Feedback: Bugs are fixed immediately. In-depth Review: The second dev is deeply involved in writing the code. On-the-job Learning: Juniors learn directly from experienced peers. It’s more of a collaborative development method than a strict review. 4. Automated Review Automated code review uses tools that analyze code for errors, style, and vulnerabilities without human intervention. These tools are triggered automatically (e.g., after compilation, commit, or pull request). They analyze, run tests (e.g., unit tests), and generate reports. Some tools can even auto-merge code if it passes checks. Automated code review is part of DevOps and is common in CI/CD pipelines before deploying to production. Types: Static Analysis: Checks code without executing it — syntax errors, bad patterns, etc. Dynamic Analysis: Runs code to detect memory leaks, threading issues, and runtime errors. However, for now, tools can't catch business logic or architectural issues. As AI evolves, tools will likely become better at "understanding" code. When is Code Review Needed? Ideally, you should conduct code reviews both in small and large-scale projects. The only exceptions might be personal side-projects (pet projects), although even these can benefit from outside input. Automated testing has become standard, from JavaScript websites to C++ libraries. Still, code review can be skipped for: Trivial changes (e.g., formatting, UI text updates) Peripheral code (e.g., throwaway scripts, config files) Auto-generated code — unless manually modified In short, review the code only if it plays a critical or central role in the app and a human wrote it. Main Stages of Conducting Code Review Regardless of whether a review is formal, informal, or automated, there are several common stages. Preparation for Review Whether the written code is a new component for a production application or a modification of an existing method in a personal project, the developer is usually motivated to have it reviewed, either by fellow developers or by using automated testing tools. Accordingly, the developer has goals for the review and a rough plan for how it should be conducted, at least in broad terms. It’s important to understand who will participate in the review and whether they have the necessary competencies and authority. In the case of automated testing, it’s crucial to choose the right tools. Otherwise, the goals of the review may not be achieved, and critical bugs might remain in the code. Time constraints also matter: when all reviewers and testing tools will be ready to analyze the code, and how long it will take. It’s best to coordinate this in advance. Before starting the actual review, it can also be helpful to self-review—go over the code yourself and try to spot any flaws. There might be problems that can be fixed immediately. Once the developer is ready for the review, they notify the reviewers via chat, pull request, or just verbally. Code Analysis and Error Detection Reviewers study the code over a period of time. During this process, they prepare feedback in various formats: suggested fixes in an IDE, chat comments, verbal feedback, or testing reports. The format of the feedback depends on the tools used by the development team, which vary from project to project. Discussion of Edits and Recommendations Reviewers and the developer conduct a detailed discussion of the reviewed codebase. The goal is to improve the code while maintaining a productive dialogue. For instance, the developer might justify certain controversial decisions and avoid making some changes. Reviewers might also suggest non-obvious improvements that the developer hadn't considered. Documentation and Task Preparation All identified issues should be clearly documented and marked. Based on this, a list of tasks for corrections is prepared. Kanban boards or task managers are often used for this, e.g., Jira, Trello, and GitHub Issues. Again, the documentation format depends on the tools used by the team. Even a solo developer working on a personal project might write tasks down in a physical notebook—or, of course, in a digital one. Though keeping tasks in your head is also possible, it’s not recommended. Nowadays, explicit tracking is better than implicit assumptions. Relying on memory and intuition can lead to mistakes. Applying Fixes and Final Approval Once the list of corrections is compiled, the developer can begin making changes. They often also leave responses to comments. Bringing code to an acceptable state may take several review rounds. The process is repeated until both reviewers and the developer are satisfied. It’s crucial to ensure the code is fully functional and meets the team’s quality standards. After that, the final version of the code is merged into the main branch—assuming a version control system is being used. Tools for Code Review In most cases, code review is done using software tools. Broadly speaking, they fall into several categories: Version control systems: Most cloud platforms using version control systems (typically Git) offer built-in review tools for viewing, editing, and commenting on code snippets. Collaboration tools: Development teams often use not just messengers but also task managers or Kanban boards. These help with discussing code, assigning tasks, and sharing knowledge. Automated analyzers: Each programming language has tools for static code analysis to catch syntax issues, enforce style rules, and identify potential vulnerabilities. Automated tests: Once statically checked, the code is run through automated tests, usually via language-specific unit testing libraries. This article only covers the most basic tools that have become standard regardless of domain or programming language. GitHub / GitLab / Bitbucket GitHub, GitLab, and Bitbucket are cloud-based platforms for collaborative code hosting based on Git. Each offers tools for convenient code review. On GitHub and Bitbucket, this is called a Pull Request, while on GitLab it’s a Merge Request. Process: The developer creates a Pull/Merge Request documenting code changes, reviewer comments, and commit history. Reviewers leave inline comments and general feedback. After discussion, reviewers either approve the changes or request revisions. Each platform also provides CI/CD tools for running automated tests: GitHub Actions GitLab CI/CD Bitbucket Pipelines These platforms are considered the main tools for code reviews. The choice depends on team preferences. The toolas are generally similar but differ in details. Crucible Atlassian Crucible is a specialized tool dedicated solely to code review. It supports various version control systems: Git, SVN, Mercurial, Perforce. Crucible suits teams needing a more formalized review process, with detailed reports and customizable settings. It integrates tightly with Jira for project management. Unlike GitHub/GitLab/Bitbucket, Crucible is a self-hosted solution. It runs on company servers or private clouds. Pros and cons: Platform Deployment Managed by Maintenance Complexity GitHub / GitLab / Bitbucket Cloud Developer Low Atlassian Crucible On-premise End user/admin High Crucible demands more setup but allows organizations to enforce internal security and data policies. Other Tools Each programming language has its own specialized tools for runtime and static code analysis: C/C++: Valgrind for memory debugging Java: JProfiler, YourKit for profiling; Checkstyle, PMD for syntax checking Python: PyInstrument for performance; Pylint, Flake8 for quality analysis These tools often integrate into CI/CD pipelines run by systems like GitHub Actions, GitLab CI, CircleCI, Jenkins. Thus, formal code review tools are best used within a unified CI/CD pipeline to automatically test and build code into a final product. Best Practices and Tips for Code Review 1. Make atomic changes Smaller changes are easier and faster to review. It’s better to submit multiple focused reviews than one large, unfocused one. This aligns with the “Single Responsibility Principle” in SOLID. Each review should target a specific function so reviewers can focus deeply on one area. 2. Automate everything you can Automation reduces human error. Static analyzers, linters, and unit tests catch issues faster and more reliably. Automation also lowers developers’ cognitive load and allows them to focus on more complex coding tasks. 3. Review code, not the developer Code reviews are about the code, not the person writing it. Criticism should target the work, not the author. Maintain professionalism and use constructive language. A good review motivates and strengthens teamwork. A bad one causes stress and conflict. 4. Focus on architecture and logic Beautiful code can still have flawed logic. Poor architecture makes maintenance and scaling difficult. Pay attention to structure—an elegant algorithm means little in a badly designed system. 5. Use checklists for code reviews Checklists help guide your review and ensure consistency. A basic checklist might include: Is the code readable? Is it maintainable? Is there duplication? Is it covered by tests? Does it align with architectural principles? You can create custom code review checklists for specific projects or teams. 6. Discuss complex changes in person Sometimes it’s better to talk in person (or via call) than exchange messages—especially when dealing with broad architectural concerns. For specific code lines, written comments might be more effective due to the ability to reference exact snippets. 7. Code should be self-explanatory Good code speaks for itself. The simpler it is, the fewer bugs it tends to have. When preparing code for review, remember that other developers will read it. The clarity of the code affects the quality of the review. Put yourself in the reviewers’ shoes and ensure your decisions are easy to understand. Conclusion Code review is a set of practices to ensure code quality through analysis and subsequent revisions. It starts with syntax and architecture checks and ends with performance and security testing. Reviews can be manual, automated, or both. Typically, new code undergoes automated tests first, then manual review—or the reverse. If everything is in order, the code goes into production. If not, changes are requested, code is updated, and the process is repeated until the desired quality is achieved.

Every network, whether it’s the entire internet or your home Wi-Fi, needs a way to tell devices apart. That’s where IP addresses come in. An IP address is basically a unique ID made up of numbers separated by dots. IP addresses can be public (or “white”), which are used to connect to the wider internet, or private (internal), which are used within local networks like your home or office. Also, IPs can be static (they stay the same) or dynamic (they change over time), and they follow one of two standards: IPv4 or the newer IPv6. In this article, we’ll break down what IP addresses are, how they work, and why understanding the difference between public and private IPs actually matters. What Is an IP Address and Why Is It Needed? An IP address (Internet Protocol Address) is a unique identifier assigned to every computing device on a network. It consists of numbers separated by dots. When a user visits a website, a request is sent from their IP to a remote server, which then responds with the web page. Without IP addresses, computers and smartphones wouldn’t be able to locate each other online. They wouldn’t know where to send or receive data. An IP address is comparable to a postal code, which tells the postman where to deliver a letter and tells the recipient where it came from. What Does an IP Address Look Like? All IP addresses are unique, since they identify individual devices in a network. However, they follow the same structural format. Examples of IPv4 addresses, which consist of four integers: 78.129.229.78 172.16.254.1 203.0.113.5 192.162.74.34 184.12.203.67 Examples of IPv6 addresses, made up of eight hexadecimal blocks: 2606:4700:4700:0db8:2001:1111 2001:4860:4860::8888 fe80::1a2b:3c4d:5e6f:7g8h 1050:0:0:0:5:600:300c:326b 2001:0db8:aa10:0001:7g8h::00fb Some IPv6 addresses may contain two colons in a row (::), which represent a sequence of zeroes. For example: Full: 2001:0db8:0000:0000:0000:0000:0000:1 Shortened: 2001:db8::1 However, the double colon (::) can only appear once in an IPv6 address, or else it would be unclear how many zeroes are omitted. For instance, the address 2001::5e6f::4860 could ambiguously mean: 2001:0000:0000:5e6f:0000:4860 or 2001:0000:5e6f:0000:0000:4860 If no double colon is used, then either the address is complete or contains full zeroes. Most operating systems allow local communication via a reserved domain name — localhost. Types and Categories of IP Addresses It’s important to distinguish between the types and categories of IP addresses. Categories of IP addresses: Public IP (Public): Identifies a device on the global internet. Private IP (Private): Identifies a device within a local network. Types of IP addresses: Static: The IP address remains the same each time the device connects to the network. Used by corporate servers. Dynamic: A new IP address is assigned each time the device connects. Used by home devices. Classification by protocol: IPv4: Four integers (0–255) separated by dots, 32 bits in size, up to 4.3 billion addresses. E.g., 192.168.1.1 IPv6: Eight hexadecimal blocks, 128 bits in size, nearly unlimited addresses. E.g., fe80::1a2b:3c4d:5e6f:7g8h In summary, categories define whether an IP is public or private, while types define whether it's permanent or temporary. What Is a Public IP and How Does It Work? A public IP address is a public (external) IP that identifies a computing device on the internet. Regular internet users connect to websites and game servers using public IPs. Domain names (like hostman.com), resolved through DNS (Domain Name System), are simply a user-friendly wrapper around public IP addresses. Thus, having a public IP is a prerequisite for any computing device to interact directly with the internet. What Is a Private IP and Why Is It Used? A private IP address is a private (internal) IP used to identify a device within a local network. The main purpose of private IPs is to conserve public IPs, which are limited in number. IPv4 uses 32 bits to encode IPs, yielding a range from 0.0.0.0 to 255.255.255.255, totaling 4,294,967,296 possible addresses (256^4, not 255^4, because counting starts from 0). With over 8 billion people on Earth, and each using multiple devices (laptops, smartphones, TVs, smart speakers, etc.), there's clearly not enough public IPs for everyone. This limitation is addressed with private IPs. These are used within local networks to identify multiple devices, all of which connect to the internet through a single public IP that represents the whole network globally. Private IPs solve several problems: Communication: Devices like computers, printers, servers, and storage systems can exchange data within a local network without each requiring its own public IP. Thousands of private IPs can coexist under a single public IP. Architecture: Enable dividing networks into subnets, like one for employees and another for guests. Security: Since private IPs are not accessible from the internet, they are shielded from direct attacks like DDoS or port scanning, reducing the risk of hacking. In short, private IP addresses: Enable local communication. Conserve public IP addresses. Reduce internet traffic load. Structure local networks. Increase device security. A practical example: A home Wi-Fi router connects multiple devices (PC, phone, TV, smart speaker). All these are part of the local network and have private IPs. However, the Wi-Fi router itself is part of the global Internet and has a public IP address. Converting a Public IP to a Private IP For an internal device to access the external internet, its private IP address is converted into a public IP using NAT (Network Address Translation) technology. The conversion occurs in several steps: Request: A device with a private IP sends a request to the Internet. Translation: A router with NAT receives the request and replaces the private IP with its own public IP. Response: The remote server receives the request from the router’s public IP and sends back a response. Reverse Translation: The NAT router receives the response and, using a matching table (a list of private IPs of internal devices), forwards it to the correct internal device. In essence, NAT rewrites IPs in data packets, enabling private IP devices to interact with the internet. There are several types of IP substitution: SNAT (Source NAT): Replaces IP in outgoing packets. Outbound requests from a private IP are forwarded through a public IP. DNAT (Destination NAT): Replaces IP in incoming packets. Inbound requests to a public IP are forwarded to an internal device’s private IP. PAT (Port Address Translation): Replaces IP in outgoing packets while retaining the original port. A variation of SNAT. Full Cone NAT: Replaces IPs in both directions. Connections can be initiated by internal or external devices. Combines SNAT and DNAT. Restricted NAT: Replaces IPs in both directions. Only internal devices can initiate connections. A limited version of SNAT + DNAT. Symmetric NAT: Replaces IPs for each unique connection, creating a new mapping every time. Only internal devices can initiate connections. A modified SNAT + DNAT combination. Until the world fully transitions to IPv6, which removes the limitations of IPv4, NAT will continue to be used in Wi-Fi routers, modems, and local networks. Of course, sharing a single public IP among multiple devices isn’t always ideal. For example, if three players are gaming on a remote server using the same Wi-Fi router, and one gets IP-banned for cheating, all three could be banned, which seems unfair. However, in such cases, rebooting the router may assign a new dynamic public IP address. Also, the router's bandwidth is shared among all connected users. So, the more devices are connected to a router, the slower the connection speed for each. Where Do public and Private IP Addresses Come From? Regardless of the IP type, a common question is: Who assigns these identifiers to devices? The answer is: DHCP. DHCP (Dynamic Host Configuration Protocol) is a technology that automatically assigns IP addresses to all new devices in a network. Whether it's a local or global network, IP assignment follows these steps: Discovery: A device connects to the network and sends a DHCPDISCOVER request for an IP. Offer: The DHCP server processes the request, finds a free IP, and replies with a DHCPOFFER, including IP, subnet mask, gateway, lease time, and DNS servers. Request: The device accepts the IP and sends a DHCPREQUEST. Acknowledge: The DHCP server confirms with a DHCPACK. The device is now authorized for the lease duration. In some cases, a private IP can be manually set on a device, which it then proposes to the DHCP server. A public IP can only be manually set if it is static and pre-assigned by an ISP. If an IP conflict arises (two devices use the same IP), the DHCP server reassigns IPs to both. Public vs Private IP: Key Differences Although public and private IPs are structurally identical, they differ in usage context: Characteristic Public IP Private IP Internet Accessibility Yes No Uniqueness Across Networks Yes No Security Lower Higher NAT Use No Yes Cost Paid Free Routing Global Local Manual Assignment No Yes Assigned By ISP Network Administrator Default IP Type Dynamic Static Public IPs are assigned by an ISP via a DHCP server and are required for global internet access. Private IPs are assigned by a local administrator (via DHCP or manually) and are for local network identification. A public IP can connect to the Internet directly. A private IP can only connect to the Internet through NAT using a public IP. Public IPs can be static or dynamic, while private IPs are typically static. When Do You Need a Public IP and When a Private IP? It’s incorrect to view public and private IPs as alternatives. For Internet access, a public IP is essential — without it, the global network is inaccessible. A public IP is needed when a device must be accessible from the Internet — typically web servers or game servers. A private IP is needed for identifying devices in a local network — such as computers, smartphones, routers, or printers. In reality, local and global networks are interconnected. Multiple devices in a local network may have unique private IPs, but all access the Internet through a single public IP. Conclusion Public IPs face outward to the global network; private IPs face inward to local networks. A public IP is essential for Internet access. A private IP is vital for internal network organization — separating devices and conserving limited public IPs. Public IPs are assigned by ISPs, while private IPs are managed by local admins. Both use DHCP to automate the process. Typically, public IPs are dynamic, and private IPs are static. A full shift from IPv4 to IPv6 will eventually eliminate the need for private IPs — but this will take time, resources, and infrastructure upgrades.