Comando G

Me lancé a aprender los comandos G por pura curiosidad y porque quería controlar mi pequeña fresadora CNC en casa; desde entonces he ido probando cursos, talleres y muchísimos simuladores hasta sentirme cómodo generando y corrigiendo G-code. Si con "comando g" te refieres a los comandos G de G-code (G0, G1, G2, etc.), lo más práctico en España es combinar formación presencial en centros técnicos con práctica en makerspaces. Yo empecé en un Fab Lab local —por ejemplo, hay buenos puntos en Barcelona y Madrid— donde pude ver máquinas en directo y preguntar a gente con experiencia. Los talleres de FP de mecanizado o de fabricación mecánica suelen tener módulos específicos sobre CNC y programación, y muchas veces organizan cursos cortos orientados a operativa de máquinas y G-code. Además, recomiendo encarecidamente instalar simuladores gratuitos: Fusion 360 (gratuito para hobbyistas), LinuxCNC, o usar controladores basados en GRBL para impresoras/CNC pequeñas; con eso puedes generar, visualizar y probar G-code sin peligro para la máquina real.

En paralelo, aproveché recursos online en español: canales de YouTube centrados en CNC y fabricación digital, foros como ForoCNC o hilos en Reddit r/CNC para dudas puntuales, y documentación oficial de controladores (GRBL, Marlin, LinuxCNC). También es muy útil buscar cursos en plataformas como Udemy o cursos MOOC técnicos que tratan CAM y mecanizado: muchos tienen ejemplos prácticos que incluyen la generación de G-code y su depuración. Si quieres aprender de forma estructurada y con certificados, contacta con centros de formación profesional o escuelas técnicas locales que ofrezcan módulos de mecanizado CNC.

Mi consejo práctico: compra o accede a una máquina pequeña (una CNC de hobby o una impresora 3D) y empieza a generar piezas sencillas con Fusion 360; exporta el G-code y pruébalo primero en simulador, luego en la máquina. Apunta a entender comandos básicos (movimientos lineales, circulares, velocidades y cambios de herramienta) y a practicar el control de seguridad. Aprender G-code en España es más fácil si te unes a una comunidad maker: el feedback en persona acelera mucho el aprendizaje y evita errores costosos. Al final, lo que más me ayudó fue romper piezas, corregir errores y preguntar en el momento: así se interioriza el lenguaje G.

Me encanta que preguntes esto: la letra 'g' puede significar cosas muy distintas según el contexto, y por eso también hay muchas alternativas según lo que estés intentando hacer.

En mi experiencia, lo más habitual es que 'g' sea un alias corto para 'git' en la terminal, o bien la bandera 'g' en expresiones regulares (por ejemplo en 's/patrón/reemplazo/g' de sed) o el prefijo de comandos en editores tipo Vim. Si lo que usas es un alias interactivo para ahorrar tecleo, las alternativas son simples y prácticas: usar 'git' entero, crear alias distintos más descriptivos (por ejemplo 'gst' para 'git status' o 'gco' para 'git checkout'), o pasarte a herramientas con interfaz distinta como 'lazygit', 'tig', 'gh' (la CLI de GitHub) o GUI como «SourceTree» o «GitKraken». En scripts y entornos donde la portabilidad importa, mejor no depender de atajos de un solo carácter; define comandos explícitos en scripts o usa rutas completas.

Si tu 'g' es la bandera global de sustitución en regex (esa 'g' que hace que la sustitución afecte a todas las coincidencias de la línea), las alternativas dependen del lenguaje: en Perl o sed la 'g' es natural, pero puedes usar 'awk' con gsub, 'perl -pe "s/foo/bar/g"' para transformaciones robustas, o pequeños scripts en Python como 'python -c "import re,sys; print(re.sub(r'foo','bar',sys.stdin.read))"'. Para editores, emplear el 'Replace All' integrado (por ejemplo en VSCode) o herramientas modernas de línea de comandos como 'rg' + 'sed' también ayudan.

Personalmente me gusta tener dos niveles: atajos para el día a día (alias en el shell que uso solo en mi máquina) y comandos explícitos para reproducir en scripts y documentación. Además, aprender alternativas como 'awk', 'perl' y 'rg' me ha dado libertad para elegir la herramienta adecuada según el caso: a veces quiero rapidez y legibilidad, otras máxima potencia. Al final, la 'g' es cómoda, pero no imprescindible; elegir bien entre legibilidad y rapidez es lo que marca la diferencia en proyectos colaborativos y en mi flujo de trabajo.

Me encanta trastear con comandos raros del sistema, y el caso del comando 'g' es uno de esos que suele confundir a mucha gente porque no es un comando estándar en todas las distribuciones: puede ser un alias, un script local, o una utilidad instalada por algún paquete. Lo primero que hago cuando encuentro algo llamado 'g' es identificar exactamente qué es en mi máquina antes de probar nada: eso te evita sorpresas y te da pistas sobre cómo usarlo correctamente.

Para saber qué es 'g' en tu sistema ejecuta estas comprobaciones rápidas: 'command -v g' o 'type -a g' te dirán si existe en el PATH y si es un alias, función o ejecutable. 'which -a g' también puede ayudar. Si te devuelve una ruta, mira el archivo con 'ls -l $(command -v g)' y abre las primeras líneas con 'head -n 40 $(command -v g)' para ver si es un script interpretado (bash/perl/python) o un binario. Si es un alias, 'alias grep "^g="' te mostrará la definición. Prueba también 'g --help' o 'man g' por si trae documentación incorporada. En distribuciones basadas en Debian puedes usar 'dpkg -S $(command -v g)' y en RPM 'rpm -qf $(command -v g)' para saber a qué paquete pertenece.

¿Qué usos comunes puedes encontrarte? Muchas personas crean un alias 'g' para 'git' (por ejemplo, alias g='git'), con lo que los comandos serían 'g status', 'g add .', 'g commit -m "mensaje"', 'g push'. Otras veces 'g' es un pequeño wrapper que ofrece atajos propios, por ejemplo 'g s' para status, 'g p' para push, etc. También puede ser una utilidad de terceros con funciones distintas; por eso comprobar el script o el binario te dice qué opciones acepta. Si ves que 'g' es un script, fíjate en los primeros comentarios o en el 'usage' interno que suelen mostrar cuando ejecutas 'g' sin argumentos.

Si no tienes 'g' y quieres uno rápido para acortar comandos de git, puedes crear un script simple en '~/bin/g' y darle permisos ejecutables. Un ejemplo básico sería:

'#!/bin/bash'
'# pequeño wrapper para git'
'case "$1" in'
' s st) git status ;;'
' a) shift; git add "$@" ;;'
' c) shift; git commit -m "$" ;;'
' p) git push ;;'
' ) git "$@" ;;'
'esac'

Guarda, haz 'chmod +x ~/bin/g' y asegúrate de que '~/bin' esté en tu PATH antes que '/usr/bin'. Con eso tendrás un 'g' personalizable y ligero. Si necesitas una herramienta más potente, busca en Github proyectos que se llamen 'g' o atajos para git; instala solo si confías en la fuente.

Al final, la clave es identificar qué es 'g' en tu entorno y leer su ayuda/documentación. Crear tu propio 'g' es sencillo y te ahorra teclear cuando trabajas mucho con git, pero siempre conviene confirmar primero para no sobrescribir nada ni depender de algo que no controlas. Espero que estos pasos te ayuden a domar ese misterioso 'g' y a sacarle partido en tu flujo de trabajo.

Me encontré varias veces con la letra g en mi terminal y siempre me divierte descubrir qué hace en cada máquina: no es un comando mágico universal, sino más bien una etiqueta que puede apuntar a muchas cosas distintas.

En equipos de desarrollo, lo que más he visto es que la gente la usa como un alias corto para «git»: por ejemplo alias g='git' hace que «g status» ejecute «git status». Si tienes ese alias, usar g acelera muchísimo los comandos repetidos. Pero no es la única posibilidad: en otros sistemas «g» puede ser una función de shell personalizada, un script colocada en alguna carpeta del PATH, o un binario instalado por alguna herramienta de terceros. Por eso siempre reviso qué es exactamente antes de usarlo a ciegas. Para investigarlo yo empleo comandos como type g, command -v g, which g y alias grep '^g=' para detectar alias; si sospecho que es una función uso declare -f g; y si es un archivo hago ls -l $(command -v g) y lo abro con less o cat para ver su contenido y el shebang. También pruebo g --help o g -h y, si existe, man g.

Si quiero replicar el comportamiento útil, lo configuro: por ejemplo en mi .bashrc o .zshrc dejo alias g='git' y así lo tengo en todas las sesiones. Y si descubro que g es un script que no conozco, lo leo y lo evalúo con cuidado antes de ejecutarlo con permisos, por seguridad. En resumen, g sirve para lo que su creador decidió: muchas veces es un atajo para «git», otras veces una herramienta distinta; lo importante es comprobar su origen y contenido y, si te resulta útil, formalizarlo con un alias o instalar la utilidad adecuada. Personalmente disfruto más la terminal cuando cada alias tiene sentido y me hace la vida más simple, así que revisar qué hace «g» siempre me salva algún minuto al día y evita sustos innecesarios.

Me fascina cómo una letra tan pequeña como la 'g' puede cambiar por completo el comportamiento de una búsqueda o una sustitución en programación; esa diminuta señal es una de mis herramientas favoritas cuando trabajo con texto y expresiones regulares.

En muchos contextos, 'g' significa 'global' y sirve para indicar que la operación debe aplicarse a todas las coincidencias, no solo a la primera. Por ejemplo, en JavaScript uso expresiones regulares como /patrón/g para buscar todas las ocurrencias dentro de una cadena; sin la 'g' sólo obtendría la primera coincidencia. En Perl y en lenguajes con sintaxis similar, el modificador 'g' se emplea en sustituciones: $texto =~ s/viejo/nuevo/g reemplaza todas las apariciones, no solo la primera. En sed y en vim también es habitual: sed 's/foo/bar/g' cambia todas las 'foo' en cada línea, mientras que en vim :%s/antiguo/nuevo/g hace lo mismo en el rango especificado. Otra variante es awk, donde gsub realiza sustituciones globales en una cadena.

Hay otro uso de 'g' que conviene distinguir: en editores como vi/ex, el comando :g/patrón/comando no es exactamente una bandera de sustitución sino un comando global que ejecuta la acción dada en todas las líneas que coinciden con el patrón; por ejemplo, :g/error/d borrará todas las líneas que contienen 'error'. También hay que tener cuidado con las combinaciones de banderas en expresiones regulares: 'g' controla la globalidad, mientras que otras letras como 'i' (insensible a mayúsculas) o 'm' (multilínea) modifican el modo de coincidencia. En JavaScript, por ejemplo, la diferencia entre /pat/g y /pat/y (sticky) puede afectar la posición de búsqueda y cómo avanzan los punteros internos.

En la práctica, uso la 'g' cuando quiero transformar o analizar texto masivamente: reemplazar tokens, contar ocurrencias con matches repetidos o iterar sobre todas las coincidencias. Un par de advertencias útiles: cuando la expresión puede coincidir con cadenas de longitud cero, el uso de 'g' puede provocar bucles infinitos o saltos inesperados si no se avanza manualmente la posición; y en algunos entornos (por ejemplo, Python con el módulo re) no existe una 'g' literalmente, sino que las funciones devuelven todas las coincidencias por defecto (re.findall) o aceptan parámetros para controlar el número de reemplazos (re.sub con count=0 para todos). Al final, entender el contexto —si es una expresión regular en código, un comando de editor o una utilidad de línea de comandos— es clave para usar la 'g' con seguridad y eficacia. Me quedo con la idea de que esa pequeña letra simplifica mucho las tareas repetitivas cuando la aplicas con cuidado y conocimiento.

Me he topado con el comando «g» en mil configuraciones distintas y siempre resulta ser una pequeña fuente de confusión cuando algo sale mal. Uno de los errores más comunes es el típico «g: command not found». Eso suele deberse a que «g» no es un comando nativo, sino un alias, un script o un enlace simbólico que no está definido en la sesión actual. Para diagnosticarlo yo suelo ejecutar command -v g o type -a g: si no devuelven nada, significa que tu shell no conoce «g». La solución suele ser tan simple como añadir el alias o la función al archivo de configuración adecuado (.bashrc, .zshrc) y volver a sourcearlo o abrir una nueva terminal. Si añadiste un script en ~/bin o /usr/local/bin, revisa que tenga permiso de ejecución con chmod +x y que la carpeta esté en tu PATH.

Otro fallo típico que he visto es que «g» existe pero no se comporta como esperas: por ejemplo tienes un alias que apunta a una subcomando concreto (alias g='git status') y luego intentas usar g commit -m '...'; claro, no funciona porque el alias está rígido. En esos casos uso una función en lugar de un alias para propagar argumentos correctamente, por ejemplo: g{ git "$@"; } y la pongo en mi .zshrc. También recordé un caso donde había colisión con otro binario llamado «g» instalado por un paquete del sistema; para comprobar eso ejecuta type -a g y verás todas las coincidencias en PATH. Si quieres forzar que «g» sea exactamente git, un truco rápido es crear un enlace simbólico apuntando al binario de git: sudo ln -s $(which git) /usr/local/bin/g (con cuidado y privilegios adecuados).

Finalmente, hay problemas de autocompletado y caché: si instalaste un alias nuevo y la tabulación no funciona, a veces ayuda un hash -r o reiniciar la sesión; en zsh y bash hay mecanismos distintos para enganchar la autocompletación de git, por lo que a veces necesitas registrar el completador para «g» también. En resumen, diagnostico con command -v / type, chequeo PATH y permisos, y si el comportamiento de los argumentos falla, cambio alias por función. Es un proceso reiterativo, pero cuando lo ajustas te ahorras muchos malabares al escribir comandos a toda prisa, y personalmente me encanta dejar ese pequeño atajo funcionando impecable en todas mis máquinas.