DEV Community: Tu codigo cotidiano

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?

Reverse proxy mínimo en Rust: enrutar tráfico por Host

Tu codigo cotidiano — Mon, 06 Jul 2026 16:28:13 +0000

Reverse proxy mínimo en Rust: enrutar tráfico por Host

Publiqué un nuevo tutorial en TuCodigoCotidiano donde construimos un reverse proxy mínimo en Rust usando únicamente la librería estándar.

La idea del tutorial es simple, pero poderosa:

Un reverse proxy no solo reenvía tráfico: también decide a dónde debe ir.

En el proyecto, el proxy escucha en:

127.0.0.1:8080

Y enruta cada petición según el header Host:

app.localhost -> 127.0.0.1:9001
api.localhost -> 127.0.0.1:9002

Qué vas a aprender

En el tutorial construimos paso a paso un proxy que:

escucha conexiones TCP con TcpListener;
lee peticiones HTTP desde un TcpStream;
extrae y normaliza el header Host;
decide el upstream correcto;
reescribe headers como Host, Connection, X-Forwarded-For y X-Forwarded-Proto;
responde 400 Bad Request cuando falta Host;
responde 404 Not Found cuando no existe una ruta;
responde 502 Bad Gateway cuando el upstream está apagado;
maneja varias conexiones usando threads;
incluye pruebas con curl.exe y tests unitarios.

Por qué hice este tutorial

Muchas veces usamos herramientas como NGINX, Caddy, Traefik o HAProxy, pero no siempre entendemos qué pasa por dentro.

Este proyecto no busca reemplazarlas. La meta es aprender la idea central:

Leer una petición, entender a qué servicio va dirigida y reenviarla al destino correcto.

Tutorial completo

Puedes leerlo aquí:

https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/reverse-proxy-minimo-en-rust-enrutar-trafico-por-host/

Si estás aprendiendo Rust, HTTP, backend, redes o DevOps, este proyecto te puede ayudar a conectar teoría con práctica.

Python Variables and Data Types Explained With a Simple Visual Analogy

Tu codigo cotidiano — Fri, 03 Jul 2026 20:14:56 +0000

When someone starts learning Python, the first line is usually something like:

print("Hola, mundo")

That line is powerful because it shows a simple idea:

you write an instruction, and the computer responds.

But the next step is even more important:

learning how to store information.

That is where variables appear.

I just published a beginner-friendly Spanish guide about variables and basic data types in Python.

The main analogy is simple:

A variable is like a labeled box where your program stores information.

For example:

nombre = "Ana"
edad = 17
altura = 1.65
esta_aprendiendo = True
lenguajes = ["Python", "HTML", "CSS"]

The guide explains, step by step:

what a variable is
why a variable has a name
what the = symbol means in Python
what a value is
why "Ana" is text
why 17 is a number
what basic data types are
how to recognize str, int, float, bool, and list

The goal is not to overwhelm beginners with technical definitions.

The goal is to help them understand this:

A variable has a name, stores a value, and that value has a data type.

I also included visual explanations so the concept feels easier to remember.

The full guide is in Spanish:

https://tucodigocotidiano.yarumaltech.com/leer_guias/variables-y-tipos-de-datos-las-cajas-donde-vive-tu-informacion/

What analogy helped you understand variables when you were learning to code?

Python for Absolute Beginners: Start With One Line of Code

Tu codigo cotidiano — Thu, 02 Jul 2026 17:03:39 +0000

Many people want to learn programming, but they stop before writing their first line of code.

Not because they are not capable.

Because programming often feels too big at the beginning:

artificial intelligence, data, automation, web development, frameworks, tools, installations, terminals, errors…

So I wrote a beginner-friendly guide in Spanish with one simple goal:

help someone understand why Python is so popular and write their first real line of code.

print("Hola, mundo")

That line looks small, but it represents something powerful:

you write an instruction, the computer reads it, and something happens on the screen.

That is the first real connection with programming.

In the guide, I explain visually and step by step:

why Python is used in artificial intelligence
why it is useful for data analysis
how it helps with automation
how it connects with web development
why it is one of the best languages for beginners
what print("Hola, mundo") means
how to try your first line without feeling overwhelmed

The goal is not to understand everything on day one.

The goal is much simpler:

“I can try this.”

Programming does not start with knowing everything.

It starts with curiosity, one simple instruction, and the confidence to keep going.

I wrote this guide for people who are just starting and need a friendly first step.

Full guide in Spanish:

https://tucodigocotidiano.yarumaltech.com/leer_guias/por-que-python-es-el-lenguaje-del-momento-tu-primera-linea-de-codigo/

What was the first line of code you ever wrote?

Build a Minimal Git in Rust: Objects, Hashes, Commits and Log

Tu codigo cotidiano — Mon, 29 Jun 2026 14:01:56 +0000

I built a MiniGit in Rust to understand how Git works internally

Git is one of those tools we use every day, but many times it feels like a black box.

We know how to run:

git init
git commit
git log

But what actually happens inside?

I wrote a full Spanish tutorial where we build a small educational version of Git in Rust, step by step.

The project creates a .minigit folder and implements the core ideas behind Git:

Reading files as exact bytes
Creating blob objects
Calculating SHA-1 hashes like Git
Saving objects by hash
Recovering content from objects
Creating minimal commits
Updating refs/heads/main
Walking commit history with log

The goal is not to replace Git.

The goal is to open the black box and understand the model:

file
  ↓
exact bytes
  ↓
blob object
  ↓
SHA-1
  ↓
.minigit/objects/<hash>
  ↓
commit
  ↓
refs/heads/main
  ↓
log

This tutorial is especially useful if you are learning Rust, Git internals, systems programming, or how content-addressed storage works.

The article is in Spanish, but the code is simple and easy to follow.

Read the full tutorial here:

https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/tu-propio-git-minimo-en-rust-objetos-hashes-commits-y-log/

I would love to know what you think, especially if you are also interested in building developer tools from scratch.

DEV Community: Tu codigo cotidiano

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

Reverse proxy mínimo en Rust: enrutar tráfico por Host

Reverse proxy mínimo en Rust: enrutar tráfico por Host

Qué vas a aprender

Por qué hice este tutorial

Tutorial completo

Python Variables and Data Types Explained With a Simple Visual Analogy

Python for Absolute Beginners: Start With One Line of Code

Build a Minimal Git in Rust: Objects, Hashes, Commits and Log

I built a MiniGit in Rust to understand how Git works internally

Safely reading values with `get()`

Primer ejemplo con `for`

`for` también puede recorrer datos

¿Y qué hace `while`?