Introduction to Programming

Programming is the art and science of writing instructions that a computer can understand and execute. It’s a skill that has transformed the world, allowing us to create everything from mobile applications to systems that control spacecraft.

If you’re beginning your journey in programming, this article will give you a solid foundation. We’ll cover what programming is, how a computer works, fundamental concepts, and the different types of languages and tools that exist.

We’ll use JavaScript for the examples because it’s an accessible, widely used language that doesn’t require complex setup to get started. But the concepts you’ll learn here are universal and apply to any programming language.

What is Programming?

Programming is the process of writing code (instructions) that a computer can execute to perform specific tasks. These instructions are written in a programming language, which is then translated into a format the computer can understand.

Think of programming as giving very precise instructions to someone who can’t make assumptions. If you tell a person “make coffee”, they can infer the necessary steps. But a computer needs exact instructions: “take the coffee pot”, “add water”, “add coffee”, “turn on the stove”, etc.

Simple example in JavaScript

// Simple instruction: display a message
console.log("Hello, world!");

// Instruction with logic: calculate something
let number1 = 5;
let number2 = 3;
let sum = number1 + number2;
console.log("The sum is:", sum);

This simple code shows how we give instructions to the computer: first we define values, then we perform an operation, and finally we display the result.

Advantages of Learning to Program

Learning to program offers numerous advantages, both professional and personal:

1. Problem Solving

Programming teaches you to think logically and systematically. You learn to break complex problems into smaller, manageable parts.

// Problem: calculate the average of an array of numbers
// Solution: break into smaller steps
function calculateAverage(numbers) {
    // Step 1: Add all numbers
    let sum = 0;
    for (let i = 0; i < numbers.length; i++) {
        sum = sum + numbers[i];
    }
    
    // Step 2: Divide by the number of elements
    let average = sum / numbers.length;
    
    return average;
}

console.log(calculateAverage([10, 20, 30, 40])); // 25

2. Automation

You can automate repetitive tasks, saving time and reducing errors.

// Automate sending emails to multiple users
function sendEmails(users) {
    for (let user of users) {
        console.log(`Sending email to ${user.email}`);
        // Real send logic would go here
    }
}

3. Creativity and Building

You can create things from scratch: applications, websites, games, tools. Programming is a form of creative expression.

4. Professional Opportunities

The demand for programmers continues to grow. It’s a valuable skill in almost every industry.

5. Critical Thinking

Programming develops critical thinking skills and attention to detail. A small error can make the entire program fail.

Software Life Cycle

Understanding the software life cycle helps you understand how an application is developed from idea to ongoing maintenance.

1. Analysis and Planning

In this phase, what the software should do, who will use it, and what problems it will solve are defined. Specifications are created and the project is planned.

Key questions: What problem does it solve? Who will use it? What features does it need?

2. Design

The software architecture is designed: how the code will be organized, what technologies will be used, how data will be structured.

Activities: Database design, interface design, system architecture.

3. Implementation (Development)

This is the phase where code is written. Developers turn the design into functional code.

// Example: Implement a login function
function login(username, password) {
    // Validate input
    if (!username || !password) {
        return { success: false, message: "Username and password required" };
    }
    
    // Verify credentials (simplified)
    if (username === "admin" && password === "12345") {
        return { success: true, message: "Login successful" };
    }
    
    return { success: false, message: "Invalid credentials" };
}

4. Testing

The software is tested to find and fix errors. It’s verified that it works correctly and meets requirements.

Types of tests:

Unit tests: Test individual functions
Integration tests: Test how parts work together
User tests: Verify the software is usable

5. Deployment

The software is put into production, where end users can use it.

Activities: Configure servers, deploy code, configure databases.

6. Maintenance

Once in production, the software needs ongoing maintenance: fix bugs, add new features, update for new technologies.

Activities: Monitoring, bug fixes, updates, improvements.

This cycle repeats continuously. The software is never “finished”; it always evolves.

Universal Logical Structures

Regardless of the language you use, there are fundamental logical structures that appear in all programming languages.

1. Variables

Variables are containers that store values. You can think of them as labeled boxes where you store information.

// Declare a variable
let name = "John";
let age = 25;
let isStudent = true;

// Variables can change
name = "Mary";
age = 30;

2. Conditionals

Conditionals allow the program to make decisions based on conditions.

// if/else: execute code if a condition is true
let temperature = 25;

if (temperature > 30) {
    console.log("It's very hot");
} else if (temperature > 20) {
    console.log("The weather is pleasant");
} else {
    console.log("It's cold");
}

// switch: multiple conditions
let day = "monday";

switch (day) {
    case "monday":
    case "tuesday":
    case "wednesday":
    case "thursday":
    case "friday":
        console.log("Work day");
        break;
    case "saturday":
    case "sunday":
        console.log("Weekend");
        break;
    default:
        console.log("Invalid day");
}

3. Loops

Loops allow repeating code multiple times.

// for: repeat a specific number of times
for (let i = 0; i < 5; i++) {
    console.log("Iteration:", i);
}

// while: repeat while a condition is true
let counter = 0;
while (counter < 5) {
    console.log("Counter:", counter);
    counter++;
}

// for...of: iterate over array elements
let fruits = ["apple", "banana", "orange"];
for (let fruit of fruits) {
    console.log(fruit);
}

4. Functions

Functions are reusable blocks of code that perform a specific task.

// Define a function
function greet(name) {
    return "Hello, " + name + "!";
}

// Use the function
let message = greet("John");
console.log(message); // "Hello, John!"

// Function with multiple parameters
function add(a, b) {
    return a + b;
}

console.log(add(5, 3)); // 8

5. Arrays

Arrays are ordered collections of elements.

// Create an array
let numbers = [1, 2, 3, 4, 5];
let names = ["John", "Mary", "Peter"];

// Access elements
console.log(numbers[0]); // 1 (first element)
console.log(names[1]); // "Mary" (second element)

// Add elements
numbers.push(6);
names.push("Anna");

// Iterate over an array
numbers.forEach(function(number) {
    console.log(number);
});

6. Objects

Objects are collections of related properties.

// Create an object
let person = {
    name: "John",
    age: 25,
    city: "Madrid",
    greet: function() {
        return "Hello, I'm " + this.name;
    }
};

// Access properties
console.log(person.name); // "John"
console.log(person["age"]); // 25
console.log(person.greet()); // "Hello, I'm John"

How a Computer Works

To program effectively, it helps to understand how a computer works at a basic level.

Main Components

CPU (Central Processing Unit): The “brain” of the computer. It executes program instructions.

RAM (Random Access Memory): Temporary storage where data and programs in use are kept. It’s fast but volatile (erased when the computer is turned off).

Storage (Hard Drive/SSD): Permanent storage where files and programs are kept. It’s slower than RAM but persists.

Input/Output: Devices like keyboard, mouse, monitor that allow interacting with the computer.

Execution Process

When you run a program:

Load: The program is loaded from storage into RAM.
Read: The CPU reads the program instructions from memory.
Execute: The CPU executes each instruction in order.
Storage: Data is saved to memory or storage as needed.
Output: Results are displayed to the user or saved.

// Example: when you run this code
let number = 10;
let result = number * 2;
console.log(result);

// The computer:
// 1. Reserves memory space for 'number'
// 2. Stores the value 10
// 3. Reserves space for 'result'
// 4. Calculates 10 * 2 = 20
// 5. Stores 20 in 'result'
// 6. Sends 20 to the console to display it

Compiled vs. Interpreted Languages

Programming languages can be classified into two main categories based on how they’re executed.

Compiled Languages

In compiled languages, the source code is fully translated to machine code before execution. This process is called “compilation”.

Advantages:

Faster execution (code is already translated)
Error detection before running
Advanced optimizations

Disadvantages:

Requires a compilation step before running
Less flexible for quick changes

Examples: C, C++, Rust, Go

Process:

Source code → Compiler → Machine code → Execution

Interpreted Languages

In interpreted languages, code is translated line by line as it runs. A program called an “interpreter” reads and executes the code.

Advantages:

Immediate execution (no compilation required)
More flexible for rapid development
Portability (same code works on different systems)

Disadvantages:

Slower execution (translation at runtime)
Some errors only detected when running

Examples: JavaScript, Python, Ruby, PHP

Process:

Source code → Interpreter → Direct execution

Hybrid Languages

Some languages use a hybrid approach: they compile to an intermediate format that is then interpreted or just-in-time (JIT) compiled.

Examples: Java, C#, TypeScript (compiles to JavaScript)

Process:

Source code → Compilation to bytecode → Virtual Machine → Execution

JavaScript is primarily interpreted, but modern engines (like V8 in Chrome) use JIT compilation to improve performance.

Typing: Static, Dynamic, Strong, Weak

“Typing” refers to how a language handles data types (numbers, text, booleans, etc.).

Static vs. Dynamic Typing

Static Typing: A variable’s type is declared and cannot change.

// In a statically typed language (conceptual example)
int number = 10;  // 'number' will always be an integer
string name = "John";  // 'name' will always be text
// number = "text";  // ERROR: you can't change the type

Dynamic Typing: A variable’s type can change during execution.

// JavaScript is dynamically typed
let value = 10;        // value is a number
value = "text";        // Now value is text (allowed)
value = true;         // Now value is boolean (allowed)

Advantages of static typing:

Early error detection
Better editor autocomplete
Implicit code documentation

Advantages of dynamic typing:

More flexible
More concise code
Faster development

Strong vs. Weak Typing

Strong Typing: The language doesn’t allow operations between incompatible types without explicit conversion.

// JavaScript has relatively strong typing
let number = 10;
let text = "5";

// You can't add directly without conversion
// console.log(number + text); // "105" (concatenation, not sum)
console.log(number + Number(text)); // 15 (explicit conversion)

Weak Typing: The language automatically converts between types, sometimes unexpectedly.

// JavaScript does some automatic conversions
console.log("5" + 3);  // "53" (converts 3 to text)
console.log("5" - 3);  // 2 (converts "5" to number)

JavaScript classification:

Dynamically typed: Types are determined at runtime
Weakly typed: Does automatic conversions between types

Frontend and Backend

Modern web applications are typically divided into two parts: frontend and backend.

Frontend (Client)

The frontend is the part of the application the user sees and interacts with directly. It runs in the user’s browser.

Responsibilities:

User interface (buttons, forms, menus)
Interactivity (animations, validations)
Data presentation
User experience

Main technologies:

HTML: Page structure
CSS: Style and design
JavaScript: Client interactivity and logic

// Frontend example: handle a form
function handleSubmit(event) {
    event.preventDefault(); // Prevent default submit
    
    let name = document.getElementById("name").value;
    let email = document.getElementById("email").value;
    
    // Validate on client
    if (!name || !email) {
        alert("Please fill in all fields");
        return;
    }
    
    // Send data to backend
    sendDataToBackend({ name, email });
}

Backend (Server)

The backend is the part of the application that runs on the server. The user doesn’t see it directly, but it handles business logic and data.

Responsibilities:

Business logic
Database access
Authentication and authorization
Data processing
APIs for communication

Main technologies:

Languages: Node.js (JavaScript), Python, Java, Go, Ruby, PHP
Databases: PostgreSQL, MySQL, MongoDB
Web servers: Express (Node.js), Django (Python), Spring (Java)

// Backend example: REST API with Node.js/Express
const express = require('express');
const app = express();

// Endpoint to get users
app.get('/api/users', function(req, res) {
    // Backend logic: get data from database
    let users = getUsersFromDB();
    res.json(users);
});

// Endpoint to create user
app.post('/api/users', function(req, res) {
    let userData = req.body;
    
    // Validate and save to database
    let newUser = createUser(userData);
    res.json(newUser);
});

Frontend-Backend Communication

The frontend and backend typically communicate via HTTP/HTTPS using APIs (Application Programming Interfaces).

// Frontend: make request to backend
async function getUsers() {
    try {
        let response = await fetch('/api/users');
        let users = await response.json();
        displayUsers(users);
    } catch (error) {
        console.error("Error fetching users:", error);
    }
}

Popular Backend Languages

Node.js (JavaScript)

Advantages: Same language as frontend, huge ecosystem, fast for development.

Use: REST APIs, real-time applications, microservices.

Example use: Netflix, LinkedIn, PayPal

Python

Advantages: Clear syntax, excellent for data science, many frameworks.

Frameworks: Django, Flask, FastAPI

Example use: Instagram, Spotify, YouTube

Java

Advantages: Very stable, used in large companies, excellent performance.

Frameworks: Spring, Spring Boot

Example use: Amazon, eBay, LinkedIn

Go

Advantages: Very fast, excellent for concurrency, fast compilation.

Use: Microservices, distributed systems, CLI tools

Example use: Docker, Kubernetes, Dropbox

C#

Advantages: Strongly typed, excellent for Windows, good performance.

Frameworks: ASP.NET, .NET Core

Example use: Microsoft, Stack Overflow

Frontend Languages and Technologies

JavaScript

JavaScript is the fundamental language of the web frontend. All browsers support it natively.

Use: Interactivity, DOM manipulation, API communication.

TypeScript

TypeScript is JavaScript with static typing. It compiles to JavaScript.

Advantages: Early error detection, better autocomplete, more maintainable code.

HTML and CSS

Although they’re not programming languages, they’re essential for the frontend:

HTML: Defines page structure
CSS: Defines style and design

Frameworks and Libraries

Frameworks and libraries are tools that facilitate development by providing reusable code and established patterns.

Frontend Frameworks

React: Facebook’s library for building user interfaces. Uses reusable components.

Vue.js: Progressive framework, easy to learn, very flexible.

Angular: Google’s complete framework, includes many built-in features.

Svelte: Compiler that generates optimized JavaScript code.

Backend Frameworks

Express (Node.js): Minimalist, flexible framework for Node.js.

NestJS (Node.js): Enterprise framework inspired by Angular, uses TypeScript.

Django (Python): “Batteries included” complete framework for Python.

Flask (Python): Minimalist, lightweight framework for Python.

Spring Boot (Java): Enterprise framework for Java, widely used in large companies.

FastAPI (Python): Modern, fast framework for APIs, excellent automatic documentation.

Useful Libraries

Lodash: JavaScript utilities (array, object manipulation, etc.)

Axios: HTTP client for making API requests.

Moment.js / date-fns: Date and time handling.

Jest / Mocha: Testing frameworks.

My personal perspective

Programming is a life-changing skill. It’s not just about writing code; it’s about thinking logically, solving problems, and creating things that impact others.

When I started programming, I felt overwhelmed by the number of concepts, languages, and tools. But over time, I realized that the fundamental concepts are universal. Once you understand variables, conditionals, loops, and functions, you can learn any language.

JavaScript is an excellent starting point because it’s accessible, doesn’t require complex setup, and you can see immediate results. But don’t marry yourself to a single language. Each language has its strengths, and understanding multiple languages makes you a better programmer.

The difference between frontend and backend can be confusing at first, but it’s important to understand it. The frontend is what the user sees; the backend is the logic that makes everything work. Both are important, and many developers specialize in one or the other, although knowing both is valuable.

Frameworks and libraries can seem overwhelming at first, but you don’t need to learn them all immediately. Start with the fundamentals: plain JavaScript, HTML, CSS. Once you understand these, frameworks make more sense because they solve problems you’ve already experienced.

Programming is a continuous learning journey. Technologies change, but fundamental concepts remain. Invest time in understanding the fundamentals, and you’ll be able to adapt to any new technology that appears.

At the end of the day, programming is about solving problems and creating value. No matter what language you use or what framework you choose, what matters is that you can build things that work and help others.