DEV Community: Tu codigo cotidiano

What Physically Happens When You Ask an AI a Question?

Tu codigo cotidiano — Tue, 11 Aug 2026 22:18:14 +0000

We often think about artificial intelligence as something purely digital.

You type a question.

Press Enter.

A few seconds later, an answer appears.

But physically, a surprising amount of infrastructure has been involved during those few seconds.

Your question first travels through networking infrastructure toward a data center. There, the text is transformed into tokens that can be processed by an AI model.

Specialized hardware—often GPUs or other accelerators—performs billions of mathematical operations to calculate what should come next.

That computation requires electricity.

Electricity produces heat.

Heat requires cooling.

And all of this happens while networking systems move information between your device, servers, memory, storage and computing accelerators.

In other words, an AI response is not simply “generated by software.”

It is the result of a physical chain involving:

Networks
Data centers
GPUs and accelerators
Memory
Electricity
Cooling systems
Large-scale distributed computing

I recently explored this idea in a new episode of TuCodigoCotidiano:

🎧 ¿Qué ocurre físicamente cuando le preguntas algo a una IA?

https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/que-ocurre-fisicamente-cuando-le-preguntas-algo-a-una-ia/

The episode is in Spanish and focuses on understanding the physical infrastructure behind something we now do every day: asking an AI a question.

ai #machinelearning #computerscience #technology

Build a Personal Expense Tracker in Python: From Fundamentals to a Real Terminal App

Tu codigo cotidiano — Tue, 28 Jul 2026 12:06:08 +0000

Learning Python syntax is one thing.

Using variables, conditionals, loops, lists, dictionaries, and functions together to build an actual program is where things start to become much more interesting.

I published a new step-by-step project in TuCodigoCotidiano where we build a personal expense tracker that runs entirely in the terminal.

The guide is written in Spanish and is designed for people who already know the basic Python concepts but want to understand how those pieces fit together inside a real application.

What we build

The project starts small.

A single expense becomes a dictionary.

Multiple expenses become a list of dictionaries.

Then we gradually add functions until the program can:

Register income
Register expenses
Display transactions
Calculate total income
Calculate total expenses
Calculate the current balance
Group expenses by category
Validate user input
Run through an interactive terminal menu
Save data to JSON
Load previous data when the program starts again

The final structure is intentionally simple:

problem → data → functions → interaction → validation → persistence → application

No classes.

No database.

No external libraries.

Just Python and the standard library.

Why I built the tutorial this way

A common beginner experience is learning concepts independently:

if

for

lists

dictionaries

functions

But knowing those concepts does not automatically explain how to design a program.

So instead of starting with a large finished script, the project begins with a practical question:

What would a program need to do to help you understand where your money is going?

From there, every new piece of code solves one specific part of the problem.

The goal is not only to finish an expense tracker.

The goal is to understand how a real program grows from a simple idea.

Read the complete project

🐍 Construye un gestor de gastos personales en la terminal

https://tucodigocotidiano.yarumaltech.com/leer_guias/construye-un-gestor-de-gastos-personales-en-la-terminal/#del-problema-cotidiano-al-programa

The complete tutorial is in Spanish and includes the code, explanations, visual diagrams, validation, JSON persistence, testing ideas, common mistakes, and challenges to extend the project.

If you were extending this project, what would you build next: budgets, dates, search, editing transactions, or something else?

The Electromagnetic Spectrum: The Invisible Infrastructure Behind Our Connected World

Tu codigo cotidiano — Mon, 27 Jul 2026 14:13:34 +0000

Before getting out of bed, you have probably already used one of the most important infrastructures in the modern world.

You checked your phone, received a message, or connected to Wi-Fi.

None of those actions would be possible without the electromagnetic spectrum.

An invisible network around us

Radio, Wi-Fi, Bluetooth, mobile networks, television, satellite communications, and many navigation systems use specific regions of the electromagnetic spectrum.

Although these technologies may appear unrelated, they all transmit information using electromagnetic waves.

What changes between them is mainly their frequency, wavelength, transmission power, and method of encoding information.

Even visible light belongs to this same family. Our eyes simply detect a very small portion of a much larger spectrum.

Frequencies as invisible lanes

Imagine hundreds of people speaking inside the same room at the same time.

Without separate conversations, turns, or channels, understanding anyone would become extremely difficult.

Something similar happens with wireless communications.

Different services use different frequency bands to reduce interference. Mobile networks, aviation, emergency services, weather systems, radio stations, and satellites must operate under carefully coordinated rules.

These frequencies work like invisible lanes through which information travels.

Some frequencies can cover long distances and pass through obstacles more effectively. Others can carry larger amounts of information but require more antennas or clearer paths between transmitter and receiver.

Internet is not a magical cloud

Wireless signals are only one part of the journey.

After reaching an antenna, information may continue through base stations, fiber-optic cables, data centers, and satellite links.

Fiber optics also use electromagnetic radiation, transmitting information through pulses of light.

The connected world therefore combines two major routes:

Electromagnetic waves travelling through the air.
Light pulses travelling through fiber-optic cables.

Together, they support everything from everyday messages to aircraft navigation, weather alerts, emergency communications, and space exploration.

Listen to the episode

In this Spanish-language episode of TuCódigoCotidiano, Javier and Laura explore the electromagnetic spectrum and explain why it can be understood as the invisible infrastructure of modern society.

🎧 Listen here:

https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/el-espectro-electromagnetico-la-infraestructura-invisible/

Cities have visible roads for vehicles and electromagnetic roads for information.

Although we cannot see them, their design determines how connected, secure, and resilient our society can become.

Python Functions for Beginners: Stop Repeating Code and Start Reusing Solutions

Tu codigo cotidiano — Fri, 24 Jul 2026 14:10:27 +0000

Copying a few lines of code may seem harmless.

But what happens when the same instructions appear three, five, or ten times throughout your program?

A small change suddenly requires editing several places. One forgotten copy may behave differently from the others, and the program becomes harder to understand and maintain.

This is one of the problems that functions help us solve.

If a task appears several times, it probably needs a name.

A function turns a group of related instructions into a reusable solution that we can execute whenever we need it.

The problem with repeated code

Imagine that we need to calculate the total price of several purchases:

product_1 = "notebook"
price_1 = 8500
quantity_1 = 3
total_1 = price_1 * quantity_1

print(f"{quantity_1} units of {product_1} cost ${total_1}")

product_2 = "pencil"
price_2 = 2000
quantity_2 = 5
total_2 = price_2 * quantity_2

print(f"{quantity_2} units of {product_2} cost ${total_2}")

The program works, but the same procedure is repeated:

Receive a product.
Receive its price.
Receive a quantity.
Calculate the total.
Display the result.

Instead of copying that procedure every time, we can create a function and give the task a descriptive name.

Creating a function with `def`

In Python, a function definition begins with the def keyword:

def greet():
    print("Hello! Welcome to Python.")

This definition contains several important parts:

def tells Python that we are defining a function.
greet is the function name.
() contains the function parameters.
: marks the beginning of the function body.
The indented instructions belong to the function.

Defining a function does not execute it automatically.

To run its instructions, we must call it:

def greet():
    print("Hello! Welcome to Python.")

greet()
greet()

Each call executes the function body again.

This distinction is essential:

A function definition describes a task. A function call asks Python to perform it.

Parameters and arguments

Our first function always displays the same message.

To make it work with different values, we can add a parameter:

def greet(name):
    print(f"Hello, {name}. Welcome to Python.")

greet("Laura")
greet("Carlos")
greet("Sofia")

In this example:

name is a parameter.
"Laura", "Carlos", and "Sofia" are arguments.

A parameter represents the information that a function expects to receive.

An argument is the actual value provided when the function is called.

The same function can therefore process different data without changing its internal instructions.

Using multiple parameters

A function can receive more than one value:

def show_total(product, price, quantity):
    total = price * quantity
    print(f"{quantity} units of {product} cost ${total}")

show_total("notebook", 8500, 3)
show_total("pencil", 2000, 5)

Python matches positional arguments with parameters according to their order:

"notebook" → product
8500       → price
3          → quantity

For this reason, both the number and order of the arguments matter.

The calculation logic now exists in only one place. We can reuse it with as many products as necessary.

Returning results with `return`

The previous function displays the calculated total.

But what happens when another part of the program needs to use that value?

This is where return becomes important:

def calculate_total(price, quantity):
    total = price * quantity
    return total

The returned value can be stored in a variable:

notebook_total = calculate_total(8500, 3)
pencil_total = calculate_total(2000, 5)

print(notebook_total)
print(pencil_total)

It can also participate in another operation:

grand_total = notebook_total + pencil_total
print(grand_total)

A returned value is not limited to being displayed.

The program can store it, compare it, transform it, send it to another function, or use it in a larger calculation.

`print()` and `return` are not the same

This is one of the most important distinctions when learning Python functions.

Consider these two examples:

def show_double(number):
    print(number * 2)


def calculate_double(number):
    return number * 2

Both functions calculate the same value, but they do different things.

show_double() displays the value:

show_double(5)

Its output is:

calculate_double() returns the value:

result = calculate_double(5)
print(result + 4)

Its output is:

A useful way to remember the difference is:

print() communicates a value to the user.
return gives the value back to the program.

Use print() when the main purpose is to display information.

Use return when the result must continue participating in the program.

Why does a function return `None`?

Every Python function call produces a result.

When a function finishes without an explicit return, Python automatically returns None.

Consider this example:

def show_total(price, quantity):
    print(price * quantity)

result = show_total(8500, 3)

print(result)

The output will be:

25500
None

The function displayed 25500, but it did not return that number.

Therefore, the value stored in result is None.

None does not mean zero, an empty string, or an error.

It represents the absence of a useful returned value.

Common beginner mistakes

1. Forgetting the parentheses

Writing the function name by itself refers to the function:

greet

Adding parentheses calls it:

greet()

The first expression identifies the function object. The second expression executes the function.

2. Sending the wrong number of arguments

A function with three required parameters expects three corresponding arguments:

def show_total(product, price, quantity):
    return price * quantity

This call is incomplete:

show_total("notebook", 8500)

Python will report an error because the quantity argument is missing.

The correct call is:

show_total("notebook", 8500, 3)

3. Sending arguments in the wrong order

Consider this function:

def show_total(product, price, quantity):
    return price * quantity

This call uses the correct number of arguments but places them incorrectly:

show_total(8500, "notebook", 3)

Python will assign:

8500       → product
"notebook" → price
3          → quantity

The names of positional parameters do not automatically identify the arguments. Their position determines how Python assigns them.

4. Trying to calculate with a function that only prints

This function displays a value but returns None:

def show_double(number):
    print(number * 2)

Therefore, this operation will fail:

result = show_double(5)
print(result + 4)

The function prints 10, but result contains None.

To reuse the calculated value, return it instead:

def calculate_double(number):
    return number * 2

result = calculate_double(5)
print(result + 4)

A practical example

Let us create a function that calculates the price of a purchase after applying a discount:

def calculate_discounted_price(price, discount_percentage):
    discount = price * discount_percentage / 100
    final_price = price - discount
    return final_price

We can now use the same solution with different values:

first_product = calculate_discounted_price(100000, 10)
second_product = calculate_discounted_price(80000, 15)

print(first_product)
print(second_product)

The output is:

90000.0
68000.0

We can also combine the returned values:

purchase_total = first_product + second_product
print(purchase_total)

This demonstrates the main advantage of return: the results can continue moving through the program.

A better way to think about functions

Functions are more than a Python syntax feature.

They help us:

Divide large problems into smaller tasks.
Give meaningful names to those tasks.
Avoid repeating instructions.
Make changes in one place.
Test individual pieces of logic.
Reuse solutions with different data.
Combine small solutions into larger programs.

When deciding whether to create a function, ask:

Does this task appear more than once?
Can I describe the task with a clear name?
Which information does the task need?
Should the function display something or return a result?
Will another part of the program need the result?

These questions transform functions from a syntax exercise into a tool for designing better programs.

Final challenge

Create a function called calculate_average that receives three grades and returns their average.

Start with this structure:

def calculate_average(grade_1, grade_2, grade_3):
    # Write your solution here
    pass

Then store the result and display it:

student_average = calculate_average(4.5, 3.8, 4.2)
print(student_average)

As an additional challenge, create another function that receives the average and returns either "Passed" or "Failed".

Continue learning

I published a complete illustrated Spanish guide that explains these concepts with additional examples, practical exercises, and common mistakes:

👉 https://tucodigocotidiano.yarumaltech.com/leer_guias/funciones-divide-los-problemas-y-reutiliza-soluciones/

What confused you the most when you first learned functions: parameters, arguments, return, or None?

Python Dictionaries and Sets: Organize Named Data and Remove Duplicates

Tu codigo cotidiano — Tue, 21 Jul 2026 16:44:17 +0000

When we start learning Python, lists are often one of the first data structures we use:

student = ["Laura", 24, "Medellín"]

This works, but what does each position represent?

We need to remember that:

Position 0 contains the name.
Position 1 contains the age.
Position 2 contains the city.

A dictionary provides a clearer alternative because every value is identified by a descriptive key.

Creating a dictionary

A dictionary stores information as key-value pairs:

student = {
    "name": "Laura",
    "age": 24,
    "city": "Medellín"
}

Instead of asking for the value at position 0, we can ask directly for the value associated with "name":

print(student["name"])

Output:

Laura

A useful way to remember the difference is:

A list position tells you where a value is. A dictionary key tells you what the value means.

Updating and adding information

Python dictionaries are mutable, so their content can change after creation.

To update an existing value:

product = {
    "name": "Keyboard",
    "price": 120000
}

product["price"] = 110000

To add a new key-value pair, use the same syntax with a key that does not exist yet:

product["available"] = True

The resulting dictionary is:

{
    "name": "Keyboard",
    "price": 110000,
    "available": True
}

Safely reading values with `get()`

Using square brackets requires the key to exist:

print(student["email"])

If "email" is missing, Python raises a KeyError.

The get() method provides a safer alternative:

print(student.get("email"))

It returns None when the key is missing.

You can also define a default value:

print(student.get("email", "Not registered"))

Output:

Not registered

To check whether a key exists, use the in operator:

if "city" in student:
    print(student["city"])

Keys, values, and pairs

Python provides three useful dictionary methods:

course = {
    "name": "Python Basics",
    "duration": "4 weeks",
    "format": "Online"
}

print(course.keys())
print(course.values())
print(course.items())

They provide different views of the same information:

keys() returns the keys.
values() returns the stored values.
items() returns complete key-value pairs.

Looping through a dictionary

The items() method is especially useful when working with a for loop:

capitals = {
    "Colombia": "Bogotá",
    "Peru": "Lima",
    "Argentina": "Buenos Aires"
}

for country, capital in capitals.items():
    print(f"{country}: {capital}")

Output:

Colombia: Bogotá
Peru: Lima
Argentina: Buenos Aires

During every iteration, Python assigns the current key to country and its associated value to capital.

What is a set?

A set is a collection that stores unique values.

Consider this list:

languages = ["Python", "Rust", "Python", "JavaScript", "Rust"]

We can remove repeated values by converting it into a set:

unique_languages = set(languages)

print(unique_languages)

The set keeps only one occurrence of each language.

Sets are useful when you need to:

Remove duplicate values.
Check whether a value is present.
Compare groups of elements.
Work with unique categories or identifiers.

Unlike lists, sets do not support indexes or slicing.

An important detail

Empty braces create an empty dictionary:

empty_dictionary = {}

To create an empty set, use set():

empty_set = set()

This is a common source of confusion for Python beginners.

Which structure should you choose?

Use a list when position and order are important.

Use a dictionary when every value should have a descriptive name.

Use a set when you need unique values and repetitions do not matter.

Understanding this distinction makes programs easier to read, maintain, and extend.

The original Spanish guide includes a step-by-step explanation with additional examples:

https://tucodigocotidiano.yarumaltech.com/leer_guias/diccionarios-y-conjuntos-datos-con-nombre-y-sin-duplicados/

What was more confusing when you first learned Python: dictionaries or sets?

Python Lists and Tuples for Beginners: Organize Data Step by Step

Tu codigo cotidiano — Thu, 16 Jul 2026 11:46:35 +0000

When you start learning Python, storing information in individual variables feels natural:

student_1 = "Ana"
student_2 = "Luis"
student_3 = "Marta"

However, this approach becomes difficult to maintain as the amount of information grows.

Python lists allow us to group related values inside a single ordered collection:

students = ["Ana", "Luis", "Marta"]

Now we can access each element using its index:

print(students[0]) # Ana
print(students[-1]) # Marta

Because lists are mutable, their elements can be updated after creation:

students[1] = "Carlos"

We can also add new information using append() or insert():

students.append("Laura")
students.insert(1, "Daniel")

To remove elements, Python provides methods such as remove() and pop():

students.remove("Ana")
removed_student = students.pop(1)

Lists can also be inspected without modifying them:

print(len(students))
print("Laura" in students)
print("Pedro" not in students)

Another useful operation is slicing, which lets us obtain part of a list:

numbers = [10, 20, 30, 40, 50]

print(numbers[1:4])
print(numbers[:3])
print(numbers[3:])

Lists are ideal when the information may change. Tuples, on the other hand, are useful when the values should remain stable.

Understanding both structures is an essential step toward building cleaner programs, processing collections of data, and working with loops, functions, APIs, and databases.

I created a practical, beginner-friendly guide explaining these concepts step by step, with examples in Spanish.

📖 Read the complete guide:

https://tucodigocotidiano.yarumaltech.com/leer_guias/listas-y-tuplas-organiza-informacion-en-orden/

What was the first real project where you needed to use a Python list?

Python Strings From Scratch: Learn to Make Your Programs Communicate

Tu codigo cotidiano — Wed, 15 Jul 2026 11:46:17 +0000

Programming is not only about performing calculations. A useful program must also be able to display names, instructions, states and results that people can understand.

I published a new Spanish guide in TuCódigoCotidiano explaining how strings work in Python from the ground up.

In this guide, you will learn:

What a string and the str data type are
How to use single and double quotes
How Python organizes characters through indexes
How to access the first and last characters
How to extract fragments using slicing
How to concatenate and repeat text
How to build clearer messages in your programs

The explanations are accompanied by practical code examples that you can copy, run and modify while learning.

Numbers allow programs to calculate. Strings allow programs to communicate.

Read the complete guide in Spanish:

https://tucodigocotidiano.yarumaltech.com/leer_guias/cadenas-de-texto-aprende-a-conversar-con-python/

How to Build a Smart Android Compass with Kotlin, Jetpack Compose, and Sensor Fusion

Tu codigo cotidiano — Mon, 13 Jul 2026 15:23:22 +0000

A compass app sounds simple: read an angle from the phone and rotate a needle.

Real sensors make the problem much more interesting.

The measurements contain noise, the phone can rotate between portrait and landscape, nearby objects can affect the magnetometer, and angles cannot always be processed like ordinary numbers.

I explored these challenges by building SmartCompass, an Android application created with Kotlin and Jetpack Compose.

What the application does

SmartCompass combines the phone's accelerometer and magnetometer to calculate its magnetic orientation.

The application can:

Calculate a magnetic heading between 0° and 359°.
Convert the heading into a cardinal direction.
Calculate pitch and roll.
Smooth accelerometer and magnetometer measurements.
Stabilize the final heading.
Correct the coordinate system when the screen rotates.
Measure magnetic field strength in microteslas.
Build a local magnetic reference.
Detect persistent changes relative to that reference.
Report the magnetometer accuracy and calibration state.
Handle devices without the required sensors.
Start and stop sensor collection according to the Android lifecycle.

It does not require GPS or location permissions because it displays magnetic north, not geographic north.

The circular-angle problem

One of the most interesting problems appears when the compass crosses north.

Consider these two measurements:

359°
1°

A regular arithmetic mean produces:

(359 + 1) / 2 = 180°

That result points south, even though both measurements are close to north.

Angles form a circle rather than an infinite line. After 359°, the next direction is 0°. A heading filter must therefore understand circular distance.

SmartCompass converts every angle into a two-dimensional unit vector:

x = cos(angle)
y = sin(angle)

The vectors can be averaged, and the resulting direction can be recovered with atan2().

This produces a value close to 0° for samples around 359° and 1°, avoiding the sudden jump to 180°.

Filtering the sensor measurements

The application uses two different filtering strategies.

First, a low-pass filter smooths the X, Y, and Z components received from the accelerometer and magnetometer:

yₜ = αyₜ₋₁ + (1 − α)xₜ

A larger alpha produces a smoother but slower response. A smaller value reacts faster but preserves more noise.

The filtered vectors are then used to calculate the device orientation.

A second circular filter stabilizes the final heading. Keeping these responsibilities separate prevents a linear filter from being incorrectly applied to circular values.

Understanding magnetic reliability

Displaying a number is not enough. The application should also communicate whether that number can be trusted.

SmartCompass uses two sources of information:

The accuracy level reported by Android.
Changes in magnetic field strength relative to a local baseline.

During the first samples, the application learns an approximate reference for the current environment. Later measurements are compared with this baseline.

A single unusual sample does not immediately trigger a warning. The change must persist across several readings. Recovery also requires multiple normal readings, preventing the interface from constantly switching between warning and normal states.

This mechanism is educational and adaptive. It cannot identify the source of a magnetic change or replace professional measuring equipment.

Keeping the domain logic independent

The mathematical and calibration components do not depend directly on Android or Jetpack Compose.

Classes responsible for tasks such as:

Normalizing angles.
Finding the shortest angular difference.
Converting headings into cardinal directions.
Filtering vectors.
Filtering circular values.
Evaluating calibration.
Analyzing magnetic measurements.

can be tested with local unit tests.

Sensor access is exposed through an abstraction, while the presentation layer receives application-specific models instead of raw SensorManager events.

This separation makes the code easier to understand, test, and extend.

A compass is more than a rotating needle

The most valuable lesson from this project is that applications working with physical measurements should expose uncertainty and state, not only a final value.

A useful compass should not merely say:

Heading: 23°

It should also be able to explain:

Direction: Northeast
Accuracy: Medium
Magnetic field: 43.2 μT
Calibration: Acceptable
Reading status: Ready

That additional context helps the user understand when the measurement is stable and when the environment or sensor may require attention.

I documented the complete implementation step by step, including the Android project structure, sensor processing, circular filters, calibration models, magnetic analysis, Compose interface, lifecycle management, and testing.

Read the complete tutorial

The full tutorial is available in Spanish:

👉 Build a Smart Compass on Android with Kotlin and Jetpack Compose

What other smartphone sensor would you use for your next Android experiment?

Bucles en Python: aprende for, while y range desde cero

Tu codigo cotidiano — Thu, 09 Jul 2026 21:10:19 +0000

Cuando empiezas a aprender Python, una de las primeras señales de avance es dejar de copiar el mismo código muchas veces.

Ahí aparecen los bucles.

Un bucle permite repetir instrucciones de forma automática. En lugar de escribir varias veces la misma línea, le dices a Python qué debe repetir y bajo qué regla debe hacerlo.

Primer ejemplo con `for`

for numero in range(1, 6):
    print(numero)

Este código muestra los números del 1 al 5.

La parte importante está aquí:

range(1, 6)

En Python, el valor final de range() funciona como límite, pero no se incluye. Por eso range(1, 6) llega hasta 5.

`for` también puede recorrer datos

Un for no solo sirve para contar. También puede recorrer elementos uno por uno:

tareas = ["comprar", "empacar", "enviar"]

for tarea in tareas:
    print("Pendiente:", tarea)

Esto es útil cuando tienes datos parecidos: tareas, productos, nombres, mensajes o pedidos.

¿Y qué hace `while`?

while repite un bloque mientras una condición siga siendo verdadera.

contador = 1

while contador <= 5:
    print(contador)
    contador = contador + 1

En este caso, el contador empieza en 1 y aumenta en cada vuelta. Cuando llega a un valor mayor que 5, la condición deja de cumplirse y el bucle termina.

Regla sencilla

Usa for cuando tienes una secuencia o una cantidad clara de repeticiones.

Usa while cuando la repetición depende de una condición.

Errores comunes

Al empezar con bucles, estos errores son normales:

olvidar los dos puntos :
no indentar el bloque
pensar que range(1, 6) llega hasta 6
no actualizar el contador en un while
copiar manualmente código que podría ir dentro de un bucle

Mini reto

Crea una lista de pedidos y recórrela con for:

pedidos = ["Pedido 1", "Pedido 2", "Pedido 3"]

for pedido in pedidos:
    print("Revisando:", pedido)

print("Todos los pedidos fueron revisados")

Guía completa

Publiqué una guía más visual y paso a paso en TuCodigoCotidiano:

👉 https://tucodigocotidiano.yarumaltech.com/leer_guias/bucles-for-y-while-el-arte-de-repetir-sin-cansarse/

La idea es que una persona principiante pueda pasar de:

“Estoy copiando el mismo código varias veces”

“Puedo usar un bucle para repetir una tarea automáticamente”.

Condicionales en Python: enseña a tu programa a tomar decisiones

Tu codigo cotidiano — Thu, 09 Jul 2026 03:01:04 +0000

Condicionales en Python: enseña a tu programa a tomar decisiones

Cuando una persona empieza a aprender Python, normalmente aprende primero a guardar datos, hacer operaciones y mostrar resultados.

Pero hay un momento clave en el aprendizaje:

cuando el programa deja de hacer siempre lo mismo y empieza a tomar decisiones.

Para eso existen los condicionales.

En esta guía explico los condicionales desde cero, con ejemplos pensados para principiantes.

Qué aprenderás

En la guía se explica:

qué es un condicional;
qué es una condición;
qué significan True y False;
cómo usar if;
cómo usar else;
cómo usar elif;
cómo evitar errores comunes;
y cómo resolver un mini reto práctico.

Ejemplo básico

edad = 17

if edad >= 18:
    print("Puedes entrar")
else:
    print("Aún no puedes entrar")

La idea es que Python revise una condición y decida qué bloque de código debe ejecutar.

Por qué es importante

Los condicionales son una de las bases de la programación.

Permiten crear programas que reaccionan a los datos, por ejemplo:

validar una edad;
aplicar un descuento;
mostrar un mensaje diferente;
elegir entre varios caminos;
tomar decisiones a partir de resultados calculados.

Guía completa

Puedes leer la guía completa aquí:

https://tucodigocotidiano.yarumaltech.com/leer_guias/condicionales-ensena-a-tu-programa-a-tomar-decisiones/

Si estás empezando con Python, esta guía te ayuda a pasar de “Python calcula” a “Python decide”.

I built Deception Mesh: an open-source Rust MVP for defensive cybersecurity telemetry

Tu codigo cotidiano — Wed, 08 Jul 2026 21:06:08 +0000

I just published Deception Mesh, an open-source cybersecurity MVP built in Rust.

Project page: https://tucodigocotidiano.yarumaltech.com/proyectos/deception-mesh/

GitHub: https://github.com/tucodigocotidiano/deception-mesh

Why I built it

Most small projects and learning environments think about security only after something goes wrong.

Firewalls, authentication and monitoring are important, but there is another useful defensive idea:

What if we could deploy small decoy services that are not real production systems, but can help us observe suspicious behavior?

That is the core idea behind Deception Mesh.

Instead of exposing only real services, the project uses lightweight decoy sensors that can capture suspicious HTTP and SSH activity and turn it into structured telemetry.

What Deception Mesh does

Deception Mesh is a defensive MVP.

It is not an offensive tool.

It does not try to exploit systems.

It does not provide attack automation.

Its purpose is to help observe suspicious interactions against decoy services and make those events easier to inspect.

The MVP includes:

HTTP decoy sensor
SSH decoy sensor
REST API
JWT authentication
Role-based access control
Webhook notifications
CSV export
Docker deployment
Documentation for local execution and testing

The technical idea

The project is based on a simple flow:

A suspicious client interacts with a decoy service.
The sensor captures the event.
The system stores or exposes the event as structured telemetry.
The operator can review the signal through logs, CSV exports, API responses or webhook notifications.

The goal is not to replace enterprise security platforms.

The goal is to show that a small, understandable and auditable deception layer can be built with practical software engineering.

Why Rust

I chose Rust because it is a strong fit for infrastructure-oriented security projects.

It gives a good balance between performance, memory safety and explicit design.

For a project that handles network-facing components, Rust also encourages discipline around error handling, data structures and system boundaries.

What I wanted to prove

With this MVP, I wanted to validate four things:

A deception-based security concept can be implemented without building a huge platform.
Rust can be used to create small defensive sensors with clean architecture.
Security telemetry can be made understandable for developers and students.
A project can be useful even when its scope is intentionally limited.

That last point matters.

This is not presented as a finished commercial product.

It is a validated MVP with a clear defensive scope and room for improvement.

Who this project is for

This project may be useful for:

Software engineering students
Cybersecurity students
Backend developers
Rust learners
People interested in defensive infrastructure
Anyone curious about deception-based security

It can also be a starting point for discussions around telemetry, detection, infrastructure hardening and practical security engineering.

Current limitations

The project is intentionally honest about its current stage.

It is an MVP.

It still needs more hardening, better testing, stronger deployment guidance and deeper validation before being treated as production-ready.

That is part of the reason I am publishing it openly.

I want feedback, technical criticism and ideas from people who care about building useful defensive systems.

Final thoughts

Deception Mesh started as a practical experiment, but it became a valuable learning project around cybersecurity, Rust, backend systems and telecommunications.

If you are interested in open-source cybersecurity, defensive telemetry or Rust-based infrastructure, I would be happy if you take a look.

GitHub: https://github.com/tucodigocotidiano/deception-mesh

Feedback, issues, stars and technical suggestions are welcome.

Python Operators and Expressions Explained for Beginners

Tu codigo cotidiano — Wed, 08 Jul 2026 00:01:13 +0000

When you start learning Python, one of the first big steps is understanding variables.

A variable lets your program remember information.

But the next step is even more powerful:

using that information to calculate results.

I recently published a new Spanish guide in my Python from scratch series:

Operadores y expresiones: haz que Python calcule por ti

The guide explains operators and expressions with simple examples, without heavy theory.

The main idea is:

A variable stores information.

An operator tells Python what to do.

An expression produces a result.

For example:

precio = 12000
cantidad = 3

subtotal = precio * cantidad
descuento = subtotal * 0.10
total = subtotal - descuento

print(total)

The guide covers:

what an operator is
what an expression is
basic arithmetic operators in Python
how to use variables inside calculations
how to store calculated results
why parentheses matter
common beginner mistakes
a small final challenge

Some basic examples from the guide are:

print(5 + 3)
print(10 - 4)
print(6 * 2)
print(20 / 5)

And one important idea for beginners:

resultado_sin_parentesis = 5 + 3 * 2
resultado_con_parentesis = (5 + 3) * 2

Both lines look similar, but they can produce different results because parentheses change the order of the calculation.

This guide is written in Spanish and is designed for people who are learning Python from zero.

Full guide:

https://tucodigocotidiano.yarumaltech.com/leer_guias/operadores-y-expresiones-haz-que-python-calcule-por-ti/

What was the first programming concept that made you feel you were finally understanding how code works?

DEV Community: Tu codigo cotidiano

What Physically Happens When You Ask an AI a Question?

ai #machinelearning #computerscience #technology

Build a Personal Expense Tracker in Python: From Fundamentals to a Real Terminal App

What we build

Why I built the tutorial this way

Read the complete project

The Electromagnetic Spectrum: The Invisible Infrastructure Behind Our Connected World

An invisible network around us

Frequencies as invisible lanes

Internet is not a magical cloud

Listen to the episode

Python Functions for Beginners: Stop Repeating Code and Start Reusing Solutions

The problem with repeated code

Creating a function with def

Parameters and arguments

Using multiple parameters

Returning results with return

print() and return are not the same

Why does a function return None?

Common beginner mistakes

1. Forgetting the parentheses

2. Sending the wrong number of arguments

3. Sending arguments in the wrong order

4. Trying to calculate with a function that only prints

A practical example

A better way to think about functions

Final challenge

Continue learning

Python Dictionaries and Sets: Organize Named Data and Remove Duplicates

Creating a dictionary

Updating and adding information

Safely reading values with get()

Keys, values, and pairs

Looping through a dictionary

What is a set?

An important detail

Which structure should you choose?

Python Lists and Tuples for Beginners: Organize Data Step by Step

Python Strings From Scratch: Learn to Make Your Programs Communicate

How to Build a Smart Android Compass with Kotlin, Jetpack Compose, and Sensor Fusion

What the application does

The circular-angle problem

Filtering the sensor measurements

Understanding magnetic reliability

Keeping the domain logic independent

A compass is more than a rotating needle

Read the complete tutorial

Bucles en Python: aprende for, while y range desde cero

Primer ejemplo con for

for también puede recorrer datos

¿Y qué hace while?

Regla sencilla

Errores comunes

Mini reto

Guía completa

Condicionales en Python: enseña a tu programa a tomar decisiones

Condicionales en Python: enseña a tu programa a tomar decisiones

Qué aprenderás

Ejemplo básico

Por qué es importante

Guía completa

I built Deception Mesh: an open-source Rust MVP for defensive cybersecurity telemetry

Why I built it

What Deception Mesh does

The technical idea

Why Rust

What I wanted to prove

Who this project is for

Current limitations

Final thoughts

Python Operators and Expressions Explained for Beginners

Creating a function with `def`

Returning results with `return`

`print()` and `return` are not the same

Why does a function return `None`?

Safely reading values with `get()`

Primer ejemplo con `for`

`for` también puede recorrer datos

¿Y qué hace `while`?