Programación on kenji.blog

Qué hacer cuando no puedes cancelar Google One (Gemini)

Sat, 27 Sep 2025 10:02:59 +0900

[Atención] ¿Se te cobrará cuando termine la prueba gratuita de Gemini? Resumen de cómo cancelar

Cuando intentas probar el servicio de IA de Google “Gemini”, inicialmente hay disponible una prueba gratuita de 1 mes. Creo que muchas personas se registran pensando “Si es gratis, lo probaré por ahora”, pero aquí hay una advertencia.

¿Qué pasa cuando termina la prueba gratuita?

Cuando termina el período de prueba, se te cobrarán automáticamente 2.900 yenes al mes. Esto está vinculado a una suscripción llamada “Membresía de Google One”, que es un sistema que hace la transición a la facturación continua si no haces nada.

Si cancelas, no se te cobrará, pero…

Por supuesto, si cancelas durante la prueba, no se te cobrará ninguna tarifa. La página de ayuda oficial también tiene un artículo sobre “Cómo cancelar tu membresía de Google One”.

👉 Cancelar la membresía de Google One (Oficial)

Sin embargo, cuando intenté acceder, me encontré en una situación en la que “por alguna razón no podía cancelar”. Me confundí y pensé: “¿Eh, desde dónde debería pararlo?”.

¡El método de cancelación correcto está aquí!

Después de investigar mucho, la página desde la que realmente pude cancelar fue la siguiente.

👉 Cuenta de Google – Eliminar un servicio

Si seleccionas “Google One” aquí y lo eliminas, la cancelación se completará.

Resumen

La prueba gratuita de Gemini dura 1 mes
Tras finalizar, se te cobrarán automáticamente 2.900 yenes al mes
Es posible que no puedas cancelar desde la página de ayuda oficial
Donde realmente puedes cancelar es en la página “Eliminar un servicio”

Si piensas “Está bien porque es una prueba gratuita”, ten cuidado de que no se te cobre sin darte cuenta.

👉 Si estás leyendo este artículo, es posible que estés en un aprieto pensando “¿Desde dónde cancelo?”. De momento, por favor revisa el enlace de arriba.

Cómo eliminar de forma masiva metadatos (información personal) de Excel, Word, etc. con PowerShell

Wed, 30 Jul 2025 02:42:40 +0900

Cómo eliminar de forma masiva metadatos (información personal) de Excel, Word, etc. con PowerShell

Los archivos de Office como Excel guardan automáticamente “metadatos (información personal)” como el autor, la persona que lo modificó por última vez, el nombre de la empresa, etc. Hay muchos casos en los que se desea eliminar esta información, como al compartir archivos fuera de la empresa.

En este artículo, explicaremos en detalle cómo eliminar metadatos de Excel usando PowerShell, enfocándonos en el procesamiento por lotes en una carpeta ** y su ** aplicación a otros archivos de Office como Word y PowerPoint.

1. Eliminar los metadatos de un solo archivo de Excel

Este es el script más básico para eliminar la información personal de un solo archivo de Excel. Llama al objeto COM de Excel, establece la propiedad RemovePersonalInformation en $true y guarda los cambios sobrescribiendo el archivo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Iniciar la aplicación Excel de forma oculta
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

# Abrir el archivo (*Especificar ruta absoluta)
$filePath = "C:\Path\To\Your\File.xlsx"
$wb = $excel.Workbooks.Open($filePath)

# Habilitar la configuración para eliminar metadatos (información personal)
$wb.RemovePersonalInformation = $true

# Guardar sobrescribiendo y cerrar
$wb.Save()
$wb.Close($false)

# Cerrar Excel y liberar memoria
$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

Nota: La ruta que se pasa a Workbooks.Open() debe ser siempre una ** ruta absoluta (ruta completa)**. El uso de rutas relativas puede causar errores.

2. Procesar todos los archivos de Excel en una carpeta en masa

En la práctica, habrá muchos casos en los que se desee “eliminar los metadatos de docenas de archivos de Excel en una carpeta específica a la vez”. Esto se puede lograr combinando Get-ChildItem con un bucle.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


$targetFolder = "C:\Path\To\Your\Folder"

# Obtener todos los archivos .xlsx y .xls en la carpeta
$excelFiles = Get-ChildItem -Path $targetFolder -Include "*.xlsx", "*.xls" -Recurse

if ($excelFiles.Count -eq 0) {
 Write-Host "No se encontraron archivos de Excel."
 exit
}

$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

foreach ($file in $excelFiles) {
 Write-Host "Eliminando metadatos de $($file.Name)..."

 # Abrir el archivo
 $wb = $excel.Workbooks.Open($file.FullName)

 # Eliminar metadatos y guardar sobrescribiendo
 $wb.RemovePersonalInformation = $true
 $wb.Save()
 $wb.Close($false)
}

$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null

Write-Host "¡Todo el procesamiento ha finalizado!"

3. Eliminar metadatos de otros archivos de Office (Word / PowerPoint)

Los metadatos se pueden eliminar no solo en Excel, sino también en Word y PowerPoint utilizando exactamente la misma lógica. Lo único que cambia es el nombre del objeto COM que se llama; la propiedad RemovePersonalInformation es común en todos.

Para Word

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$word = New-Object -ComObject Word.Application
$word.Visible = $false
$word.DisplayAlerts = 0

$doc = $word.Documents.Open("C:\Path\To\Your\File.docx")
$doc.RemovePersonalInformation = $true
$doc.Save()
$doc.Close()

$word.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($word) | Out-Null

Para PowerPoint

En el caso de PowerPoint, la configuración de la propiedad RemovePersonalInformation es la misma, pero el comportamiento del inicio oculto es un poco diferente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ppt = New-Object -ComObject PowerPoint.Application

# Abrir especificando el modo oculto (msoFalse), etc. del segundo al cuarto argumento
$presentation = $ppt.Presentations.Open("C:\Path\To\Your\File.pptx", $false, $false, $false)
$presentation.RemovePersonalInformation = $true
$presentation.Save()
$presentation.Close()

$ppt.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($ppt) | Out-Null

Resumen

Aprovechando PowerShell y los objetos COM, puede automatizar completamente la eliminación de metadatos de archivos de Office. Para evitar la filtración accidental de información confidencial o nombres personales, es muy útil tener a mano un script de procesamiento por lotes para carpetas antes de entregar los archivos.

Pasos para llamar a TinyLLaMA desde C++ (usando llama.cpp)

Sat, 19 Jul 2025 09:40:53 +0900

✅ Configuración de TinyLLaMA × C++ (usando `llama.cpp`)

🔧 Paso 1: Preparar llama.cpp

1-1. Entorno necesario (mínimo)

SO: Windows / Linux / macOS
Entorno de desarrollo: g++ / clang / MSVC
Git / CMake

1-2. Obtener y compilar llama.cpp

1
2
3
4
5
6


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build
cmake ..
cmake --build . --config Release

En Windows, es más fácil usar Visual Studio Developer Command Prompt y ejecutar cmake --build . --config Release.

📦 Paso 2: Descargar y convertir el modelo TinyLLaMA

2-1. Obtener el modelo original de HuggingFace

Ejemplo: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# Instalar transformers para descargar si es necesario
pip install transformers huggingface_hub

python3 -m transformers.models.llama.convert_llama_weights_to_hf \
 --input_dir ./TinyLlama-1.1B-Chat \
 --model_size 1B \
 --output_dir ./hf_model

Este paso es para convertir al formato de Hugging Face.

2-2. Convertir al formato GGUF (para `llama.cpp`)

1
2


cd llama.cpp
python3 convert.py ./hf_model --outfile tinyllama.gguf

2-3. Cuantización del modelo (reducción de tamaño)

1

./quantize ./tinyllama.gguf ./tinyllama-q4.gguf q4_0

q4_0 es cuantización de 4 bits. El tamaño del modelo se reducirá a aproximadamente 350 MB.

🧪 Paso 3: Llamar al modelo desde C++ (Ejemplo de código)

3-1. Código C++ simple (Inferencia)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include "llama.h"
#include <iostream>

int main() {
 llama_model_params model_params = llama_model_default_params();
 llama_context_params ctx_params = llama_context_default_params();

 llama_model *model = llama_load_model_from_file("tinyllama-q4.gguf", model_params);
 llama_context *ctx = llama_new_context_with_model(model, ctx_params);

 std::string prompt = "El usuario dice que quiere leer datos de Excel, filtrarlos y guardarlos. ¿Cuál es la configuración de los nodos?";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // Tokenización
 std::vector<llama_token> tokens(prompt.size() + 8);
 int n = llama_tokenize(model, prompt.c_str(), tokens.data(), tokens.size(), true);
 tokens.resize(n);

 for (size_t i = 0; i < tokens.size(); ++i) {
 batch.token[i + 1] = tokens[i];
 }

 batch.n_tokens = tokens.size() + 1;
 llama_decode(ctx, batch);

 // Obtener resultados de inferencia
 for (int i = 0; i < 50; ++i) {
 llama_token next = llama_sample_token(ctx, nullptr);
 std::cout << llama_token_to_str(model, next);
 llama_batch next_batch = llama_batch_init(1, 0, 1);
 next_batch.token[0] = next;
 next_batch.n_tokens = 1;
 llama_decode(ctx, next_batch);
 }

 llama_free(ctx);
 llama_free_model(model);
 return 0;
}

🧱 Paso 4: Método de compilación (Ejemplo)

1

g++ -I./llama.cpp main.cpp ./llama.cpp/build/libllama.a -o tiny_infer -pthread -std=c++11

libllama.a se crea en el directorio build/ después de compilar.

✅ Ejemplo de estructura del producto final (Organizado)

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # Modelo cuantizado (~350MB)
├── main.cpp # Código C++ anterior
├── llama.cpp/ # Código fuente de llama.cpp
└── build/
 └── libllama.a # Biblioteca compilada

🧠 Notas adicionales para aplicar a tu caso de uso

Tener código en C++ que reciba la salida y compare y seleccione plantillas de nodos.
Ejemplo: Si contiene “Excel”, “filtro” y “guardar” → Generar los nodos correspondientes.
Esta parte puede ser tan simple como sentencias if + lectura de plantilla JSON.

📌 Resumen

Elemento	Descripción
Modelo recomendado	TinyLLaMA-1.1B-Chat v1.0 (GGUF + Cuantización)
Tamaño	~350-450MB (Cuantización 4bit)
Integración C++	Posible usando `llama.cpp`, casi sin dependencias externas
Capacidad de procesamiento	Suficiente para comprensión de intención simple y generación de salida (texto natural → configuración)
Extensibilidad	Se puede combinar con el llenado de ranuras (slots) y llamadas a plantillas para crear una IA de generación de nodos

Ventajas y desventajas de crear programas con Win32API + C++

Sat, 12 Jul 2025 12:30:35 +0900

Atractivo y desafíos de desarrollar con Win32API + C++

Para aquellos que quieren profundizar en el desarrollo de aplicaciones para Windows, Win32API + C++ sigue siendo una opción poderosa. Esta combinación, que permite interactuar con el sistema operativo desde la distancia más corta, combina alta velocidad y flexibilidad.

Por otro lado, difiere enormemente de los estilos de desarrollo modernos, por lo que su aprendizaje requiere determinación.

En esta página, explicaremos las ventajas y desventajas de forma sencilla desde la perspectiva de un desarrollador activo de aplicaciones para Windows.

Ventajas

Ejecución nativa ultrarrápida

Dado que C++ y Win32API funcionan en la capa más cercana al sistema operativo, casi no hay sobrecarga innecesaria. La eficiencia en el uso de CPU y memoria es muy alta, presumiendo de una velocidad de ejecución abrumadora.

Alta flexibilidad y libertad

Puede controlar de forma precisa y por sí mismo todos los comportamientos de la aplicación, como el control de ventanas, el procesamiento asíncrono, la integración COM y la gestión de procesos. También es posible crear herramientas especializadas para un propósito o su propio marco de trabajo personalizado.

Fácil de distribuir sin necesidad de tiempo de ejecución

Dado que no se requieren tiempos de ejecución externos como .NET o Java, se puede distribuir solo con un archivo ejecutable. Es menos propenso a problemas durante la redistribución y es atractivo porque es fácil de ejecutar incluso sin un instalador.

Se pueden crear aplicaciones ligeras

Dado que solo requiere la configuración mínima necesaria, se caracteriza por una huella de memoria muy pequeña. Funciona de manera fluida incluso en PC con bajas especificaciones o entornos de máquinas virtuales.

Control avanzado a nivel de sistema operativo posible

Puede realizar controles que son difíciles con lenguajes y bibliotecas normales, como el hook global del ratón/teclado, el ajuste fino del estilo de la ventana y la manipulación del menú del sistema.

Desventajas

Baja eficiencia de desarrollo

La construcción de la GUI también debe hacerse completamente mediante código, y a veces se necesitan decenas de líneas de código solo para crear un botón. Las modificaciones por cambios de diseño también son engorrosas, y la productividad es más baja en comparación con el desarrollo utilizando un marco de trabajo de UI.

La mantenibilidad tiende a disminuir

Hay mucho código de estructura especial, como bucles de mensajes y procedimientos de ventana, lo que dificulta la legibilidad y la reutilización. También tiene aspectos que lo hacen inadecuado para el desarrollo en equipo y el mantenimiento a largo plazo.

El soporte para UI moderna es tedioso

Es difícil soportar la UX requerida en los últimos años, como soporte de alto DPI, interfaz táctil, accesibilidad y modo oscuro. Se necesita tiempo y esfuerzo porque requiere hacerlo manualmente uno por uno.

No soporta multiplataforma

Como es una API completamente exclusiva de Windows, no se puede portar a macOS o Linux. Si asume la implementación en múltiples plataformas, necesitará seleccionar otras tecnologías.

El costo de aprendizaje es extremadamente alto

Debe comprender conceptos y mecanismos que rara vez se usan en la actualidad, como manejadores (handles), GDI, COM y OLE. Mucha de la documentación es antigua, y el aprendizaje requiere tiempo y perseverancia.

Usos adecuados

Herramientas ligeras como lanzadores de archivos y asistencia de teclas de acceso rápido
Utilidades del sistema como operaciones del portapapeles y control IME
Aplicaciones de tipo control nativo como hooks globales y captura de ventanas
Herramientas de asistencia de controladores que están estrechamente vinculadas al hardware

Usos no adecuados

Aplicaciones dirigidas a consumidores generales donde se enfatiza la UI/UX moderna
Prototipado y desarrollo MVP que prioriza la velocidad
Proyectos a gran escala que asumen operaciones a largo plazo y desarrollo en equipo
Productos multiplataforma que necesitan soportar múltiples sistemas operativos

Resumen de evaluación

Punto de vista	Evaluación
Velocidad de ejecución	◎ Muy rápida
Eficiencia de memoria	◎ Excelente
Velocidad de desarrollo	× Lenta
Mantenibilidad	× Baja
Soporte multiplataforma	× No soportado
Soporte UI moderna	× Débil
Grado de libertad de control del SO	◎ Abrumadoramente alto

Conclusión

Win32API + C++ es una herramienta adecuada para desarrolladores que “quieren manejar todo el sistema operativo por sí mismos”. Si bien su poder es muy grande, el aprendizaje y la operación requieren la correspondiente determinación.

Si vale la pena “elegirlo a propósito” depende de la naturaleza de la aplicación a la que apunte.

Sumergirse en el mundo de #include <windows.h> sin depender de marcos de trabajo GUI o lenguajes modernos… Esa elección sigue siendo significativa hoy en día.

FizzBuzz

Fri, 18 Apr 2025 00:58:11 +0900

¿Qué es FizzBuzz, al final de cuentas?

¡Hola!

Hoy me gustaría escribir sobre “FizzBuzz”.

Tanto para los que dicen “¡Ah, ya lo conozco!” como para los que piensan “He escuchado de eso, pero no lo entiendo bien”, acompáñenme un momento por favor. Se lee en unos pocos minutos, y quizás terminen diciendo “Ya veo”.

¿Es verdad que “si no puedes escribir FizzBuzz, no sirves como programador”?

FizzBuzz, en resumen, es algo como esto.

1
2
3
4
5
6
7
8
9


for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else:
 print(i)

Sí, este es el famoso “problema de FizzBuzz”.

Se revisan los números del 1 al 100 en orden,
si es múltiplo de 3, se muestra “Fizz”, si es múltiplo de 5, “Buzz”,
y si es múltiplo de ambos, “FizzBuzz”. Es algo extremadamente simple.

Sin embargo, por alguna razón, a menudo es tratado como “la prueba mínima para un programador”. Aparece en entrevistas, y en las redes sociales de vez en cuando se ven actitudes arrogantes como “Alguien que ni siquiera puede escribir FizzBuzz…”.

Pero, un momento.

¿Realmente se puede afirmar que “no poder escribir FizzBuzz = no poder programar”?

No se trata de si puedes hacerlo, sino de si estás en el “estado” para hacerlo

Es cierto que FizzBuzz requiere comprender la sintaxis y el pensamiento lógico básico. Por lo tanto, es comprensible que se use para “comprobar los fundamentos”.

Pero, piénsenlo.

Si el entorno es diferente, el resultado también lo será.

Por ejemplo,

Cuando estás nervioso frente a un entrevistador que ves por primera vez
Cuando de repente te dan una pizarra y no tienes un editor a la mano
Cuando te preguntas “¿Qué era modulo otra vez?” y no te acuerdas al instante

…¿No les ha pasado eso? Somos humanos. Creo que sí pasa.

Por eso, creo que más que “si puedes escribir FizzBuzz”, lo que en realidad es importante es “si puedes llevarte a un estado donde puedas escribir FizzBuzz”.

La trampa del típico consejo “solo entrénate y estarás bien”

Cuando se habla de esto, suele surgir el consejo “¡Por eso debes practicar todos los días!”.

Es cierto que la práctica repetitiva te permite escribir con fluidez, y eso en sí mismo es bueno. Pero si nos basamos en la premisa de que “si no puedes escribir FizzBuzz, estás descalificado”, a veces simplemente se convierte en miedo.

Es decir, se tiende a crear una estructura donde sientes que “cometer un error = no sirvo”.

Por ejemplo, el día que te quedas dormido por la mañana tiendes a pensar “soy un perezoso…”. Pero puede ser simplemente que tu cuerpo estaba cansado.

Con FizzBuzz pasa lo mismo.

A pesar de todo, FizzBuzz también es un buen problema

A pesar de todo, no es que FizzBuzz sea malo.

Al contrario, creo que es un problema muy bien hecho. Las reglas son simples y es fácil de expandir. Por ejemplo, si lo cambias de esta manera, el pensamiento se profundiza más.

1
2
3
4
5
6
7


for i in range(1, 101):
 output = ""
 if i % 3 == 0:
 output += "Fizz"
 if i % 5 == 0:
 output += "Buzz"
 print(output or i)

Este es un ejemplo de que “puedes escribirlo sin usar if-elif-else”. Es un poco más elegante, ¿verdad?

En otras palabras, FizzBuzz no solo sirve para ver “si pudiste hacerlo”, sino que también es una puerta de entrada para ver “cómo lo escribes” y “hasta qué punto lo entiendes”.

En conclusión

Creo que no hay que darle un significado demasiado exagerado a si puedes hacer FizzBuzz o no.

Incluso si no pudiste escribirlo, puede que simplemente “hoy estabas en un mal momento”, y a menudo puedes hacerlo si lo piensas detenidamente después.

Sin apresurarnos, avancemos lentamente.

El código es escrito por humanos. Por ser humanos, a veces olvidamos y a veces nos ponemos nerviosos. Creo que es suficiente si podemos avanzar poco a poco mientras aceptamos eso.

Entonces, escribamos código de manera relajada hoy también.

La Torre de Hanói

Thu, 17 Apr 2025 22:23:14 +0900

La Torre de Hanói

¡Hola!

Hoy me gustaría explicar sobre “La Torre de Hanói” junto con un programa de ejemplo en Python.

¿Qué es La Torre de Hanói?

La Torre de Hanói es un rompecabezas que usa 3 varillas y varios discos. Los discos tienen diferentes tamaños y, al principio, están apilados en una sola varilla en orden de tamaño de mayor a menor. Las reglas son las siguientes:

Solo se puede mover un disco a la vez.
No se puede colocar un disco más grande sobre uno más pequeño.

Este rompecabezas se considera un material didáctico excelente para aprender el pensamiento recursivo. La recursividad es un método para resolver un problema dividiéndolo en problemas más pequeños del mismo tipo. En la Torre de Hanói, para mover n discos, se repite la operación de mover n-1 discos.

Resolvamos la Torre de Hanói en Python

A continuación, se muestra un código de ejemplo en Python para resolver la Torre de Hanói.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def hanoi(n, source, target, auxiliary):
 if n == 1:
 print(f"Move disk 1 from {source} to {target}")
 return
 hanoi(n - 1, source, auxiliary, target)
 print(f"Move disk {n} from {source} to {target}")
 hanoi(n - 1, auxiliary, target, source)

# Ejemplo: Mover 3 discos de A a C
hanoi(3, 'A', 'C', 'B')

En este código, la función hanoi se llama recursivamente y se muestran los pasos para mover los discos. Por ejemplo, para 3 discos, se obtiene la siguiente salida:

1
2
3
4
5
6
7


Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C

De esta manera, al usar un enfoque recursivo, se pueden resolver problemas complejos de forma sencilla.

¿Cuánto tiempo se tarda en mover 64 discos?

El número de movimientos en la Torre de Hanói requiere al menos 2^n - 1 veces. Es decir, para mover 64 discos, se necesitan 2^64 - 1 veces, aproximadamente 1.84×10^19 movimientos. Incluso si pudieras mover uno por segundo, tomaría unos 584,900 millones de años. Esto es aproximadamente 42 veces la edad del universo (unos 13,700 millones de años).

Así, a medida que aumenta el número de discos, el número de movimientos necesarios aumenta exponencialmente. Por lo tanto, no es realista mover 64 discos en la práctica.

Resumen

La Torre de Hanói es el rompecabezas perfecto para aprender el pensamiento recursivo. Usando Python, puedes implementar fácilmente su solución. Sin embargo, debes tener cuidado porque a medida que aumenta el número de discos, el número de movimientos necesarios aumenta drásticamente.

Al comprender el enfoque recursivo y escribir el código tú mismo, puedes mejorar tus habilidades de programación. ¡Por favor, intenta el desafío de la Torre de Hanói!

Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI

Wed, 16 Apr 2025 01:58:03 +0900

🎯 Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI (Visual Studio 2022 / C++)

✅ Arquitectura general

🔹 ① DLL envoltura CLI (C++/CLI)

Proporciona la funcionalidad para ejecutar scripts de PowerShell.

🔹 ② Lado de llamada C++ nativo

Llama a la DLL CLI para ejecutar el script de PowerShell.

🔧 Paso 1: Creación del proyecto de la DLL envoltura CLI

1. Creación del proyecto

[Crear un proyecto nuevo] → [C++] → Biblioteca de clases CLR (.NET Framework)
Nombre: PowerShellWrapper

💡 Si no ves esta plantilla, instala la carga de trabajo “Desarrollo de escritorio de .NET”.

2. Añadir paquete NuGet

Haz clic derecho en el proyecto → [Administrar paquetes NuGet]
Busca e instala System.Management.Automation
(Versión 5.x o 7.x)

3. Implementación del código en el lado CLI

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 Paso 2: Llamada desde el lado de C++ nativo

1. Crear proyecto de aplicación de consola C++

Nombre: NativeApp

2. Configurar referencias

Haz clic derecho en el proyecto → [Agregar] → [Referencia] → [Proyectos] → Agrega PowerShellWrapper
[Propiedades de configuración] → [C/C++] → [Soporte de Common Language Runtime] → Cambiar a /clr

3. Código de ejecución (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 Nota adicional (IDL / TLB / Registro COM)

Esta configuración hace referencia directa a una DLL de .NET en lugar de COM, por lo tanto, no se requiere IDL, TLB ni registro COM.

✅ Estructura final

1
2
3
4
5


Solution
├── PowerShellWrapper (DLL C++/CLI)
│ └── PowerShellExecutor
├── NativeApp (EXE C++)
 └── main.cpp → Llamada a la DLL

Procedimiento de restauración de software (inicialización/reparación) para dispositivos Android (Google Pixel)

Fri, 28 Feb 2025 01:20:41 +0900

Procedimiento de restauración para dispositivos Android (Google Pixel)

Si tu dispositivo Google Pixel sufre un problema grave del sistema, como “reinicios constantes (bootloop)”, “se queda bloqueado en la pantalla del logotipo” o “el funcionamiento se vuelve extremadamente inestable”, puedes usar la herramienta oficial de Google “Pixel Update and Software Repair” para reparar (restaurar) de forma segura el software de tu dispositivo a través del navegador.

En este artículo, explicaremos en detalle el procedimiento específico y los puntos a tener en cuenta.

1. Acceder a la herramienta de restauración

Primero, accede a la página oficial de la herramienta de reparación desde el navegador (se recomienda Google Chrome o Microsoft Edge) de tu PC (Windows o Mac).

🔗 Sitio oficial de Pixel Update and Software Repair

※Nota※ Al ejecutar el proceso de restauración, es posible que los datos del dispositivo (fotos, aplicaciones, contactos, etc.) se borren (inicialicen) por completo. Si el dispositivo aún se puede utilizar, asegúrate de realizar previamente una copia de seguridad en Google Drive u otro servicio.

2. Preparación previa para la restauración

Para que el proceso se desarrolle sin problemas, prepara lo siguiente:

Cargar la batería Si el dispositivo se apaga durante el proceso, existe el riesgo de que se convierta en un “ladrillo” (se averíe por completo). Asegúrate de tener al menos un 50% de batería, y preferiblemente cárgalo por completo.
Preparar el cable USB original Para garantizar una transferencia de datos estable, se recomienda encarecidamente utilizar el cable USB-C original incluido con el dispositivo.
(Si es necesario) Instalar controladores Si utilizas un PC con Windows, es posible que el dispositivo no se reconozca correctamente. En ese caso, instala el Controlador USB de Google.

3. Pasos específicos de la restauración

Una vez completada la preparación, sigue las instrucciones en pantalla para proceder con la restauración.

Paso 1: Selección del operador y conexión del dispositivo

Al abrir el sitio, primero verás una pantalla para seleccionar tu operador de telefonía (compañía telefónica). Si tienes una versión libre (SIM-free) o no estás atado a un operador, selecciona “Otros (Other)” u opciones similares. A continuación, conecta tu PC y tu dispositivo Pixel con el cable USB.

Paso 2: Poner el dispositivo en “Modo de rescate (Rescue Mode / Fastboot)”

Siguiendo las instrucciones en pantalla, con el dispositivo apagado, mantén presionados simultáneamente el “botón de encendido” y el “botón de bajar volumen” para iniciar el modo Fastboot (una pantalla con fondo negro y la mascota de Android tumbada).

Paso 3: Reconocimiento del dispositivo en el PC

Haz clic en el botón “Conectar dispositivo” en el navegador; se abrirá una ventana emergente que mostrará una lista de los dispositivos Pixel conectados. Selecciona tu dispositivo y permite la conexión.

Paso 4: Descarga e instalación del software

Una vez reconocido el dispositivo, se seleccionará automáticamente la versión más adecuada del sistema operativo Android (firmware). Al hacer clic en “Instalar”, el software se descargará en el PC e inmediatamente comenzará a escribirse (flashearse) en el dispositivo.

⚠️ Advertencia: Durante este proceso, ** nunca desconectes el cable USB ni apagues el PC.**

Paso 5: Finalización y configuración inicial

El proceso de restauración será un éxito cuando la barra de progreso alcance el 100% y aparezca el mensaje de “Completado”. El dispositivo se reiniciará automáticamente y mostrará la pantalla de configuración inicial, como cuando lo compraste (la pantalla de “Hola”).

Resumen

La herramienta oficial de reparación de Google Pixel es una excelente utilidad que te permite restaurar el firmware de forma segura con solo unos clics en el navegador, sin necesidad de ejecutar directamente comandos especiales (adb o fastboot).

Antes de llevar tu dispositivo a una tienda debido a problemas de funcionamiento, te recomendamos intentar este procedimiento; es posible que el problema se resuelva fácilmente. Esperamos que esta guía te sea de utilidad.

Fragmentos de código de Python

Mon, 24 Feb 2025 18:21:14 +0900

Esta es una introducción a ejemplos de código utilizando la biblioteca estándar.

Descargar y mostrar una imagen

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


import urllib.request
import tempfile
import os
import webbrowser
import time

url = "https://www.aomori-ringo.or.jp/kids/wp-content/uploads/2021/11/apple.png"

try:
 with urllib.request.urlopen(url) as response:
 img_data = response.read()

 # Guardar en un archivo temporal y mostrar
 with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
 tmp.write(img_data)
 print(f"file://{tmp.name}")
 webbrowser.open(f"file://{tmp.name}")
 time.sleep(3)
except Exception as e:
 print(f"Ocurrió un error: {e}")

finally:
 if 'tmp' in locals():
 os.unlink(tmp.name) # Eliminar archivo temporal

Llamar a la API de ChatGPT desde curl

Sat, 01 Feb 2025 17:15:34 +0900

Llamar a la API de ChatGPT desde curl

Se asume que se llama desde el símbolo del sistema de Windows.

1
2

curl https://api.openai.com/v1/chat/completions -H "Content-Type: application/json" -H "Authorization: Bearer sk-proj-XXXXXXXXXXXXXXXXXXXX" -d "{""model"": ""gpt-3.5-turbo"",""messages"": [{""role"": ""system"", ""content"": ""Por favor, responde en dialecto de Kansai.""}, {""role"": ""user"", ""content"": ""Inserta el mensaje que deseas enviar aquí""}]}"

LoadIcon no necesita llamar a DestroyIcon

Fri, 19 Apr 2024 01:55:17 +0900

Sobre la necesidad de llamar a DestroyIcon

Es necesario llamar a DestroyIcon en los siguientes casos:

CreateIconFromResourceEx (si se llama sin la bandera LR_SHARED)
CreateIconIndirect
CopyIcon

Cuando el icono es creado por las funciones anteriores.

LoadIcon
LoadImage (cuando se usa la bandera LR_SHARED)
CopyImage (cuando se usa la bandera LR_COPYRETURNORG y el parámetro hImage es un icono compartido)
CreateIconFromResource
CreateIconFromResourceEx (cuando se usa la bandera LR_SHARED)

Los iconos creados y cargados en los casos anteriores no deben llamar a DestroyIcon.

Referencias

Función DestroyIcon (winuser.h)

Colección de fuentes para usar en programación

Sat, 30 Mar 2024 02:21:31 +0900

JetBrains Mono

Es una fuente de programación de código abierto proporcionada por JetBrains.

Descarga: https://www.jetbrains.com/ja-jp/lp/mono/

HackGen

Hakugen (HackGen) es una fuente de programación que sintetiza la fuente en inglés para programación Hack, y la fuente derivada Genjyuu Gothic de Source Han Sans (Gen no Kaku Gothic).

Descarga: https://github.com/yuru7/HackGen/releases

Ricty Diminished

Ricty Diminished es una fuente hermana de Ricty, y es una fuente sintetizada a partir de Inconsolata y Circle M+ 1m usando el script generador de Ricty, en lugar de Inconsolata y Migu 1M. Como no incluye los glifos de IPA Gothic, el número de glifos de kanji utilizables es menor, pero a cambio, puede ser distribuida bajo la SIL Open Font License.

Descarga: https://rictyfonts.github.io/diminished

Cica

Es una fuente de programación que usa Hack + DejaVu Sans Mono para caracteres alfanuméricos y símbolos. Y Rounded Mgen+ para los demás caracteres.

Descarga: https://github.com/miiton/Cica/releases

Referencia:

Migu

Es una fuente sintetizada de M+ e IPA.

Descarga: https://itouhiro.github.io/mixfont-mplus-ipa/migu/

Osaka

Es una fuente que permite usar la fuente estándar de Mac OS Osaka en Windows.

Descarga: http://ifs.nog.cc/osakattf.hp.infoseek.co.jp/

PlemolJP

Es una fuente de programación que combina la fuente japonesa de código abierto IBM Plex Sans JP lanzada por IBM y IBM Plex Mono de la serie Plex de IBM.

Descarga: https://github.com/yuru7/PlemolJP/releases

'Ejemplo usando wxWidgets'

Tue, 18 Apr 2023 00:18:22 +0900

¿Qué es wxWidgets?

wxWidgets es una biblioteca GUI de C++ que funciona en plataformas como Windows, Mac, Linux, Android, iOS, entre otras.

Instalación de wxWidgets

Abre https://www.wxwidgets.org/downloads/ y descarga Windows Installer.
Ejecuta wxMSW-3.2.2.1-Setup.exe para instalar.
Abre “C:\wxWidgets-3.2.2.1\build\msw\wx_vc17.sln” desde la carpeta instalada.
Una vez abierto wx_vc17.sln, selecciona Compilar > Compilar por lotes (Build > Batch Build).
Haz clic en el botón Seleccionar todo y luego en el botón Recompilar.
Cierra Visual Studio una vez que finalice la compilación.

Creación de un proyecto de ejemplo

Abre Visual Studio.
Selecciona Archivo > Nuevo > Proyecto.
Selecciona Aplicación de escritorio de Windows (pestañas C++, Windows, Escritorio).
Ingresa wxWidgetsSample en Nombre del proyecto.
Haz clic en Crear.
Haz clic derecho en wxWidgetsSample y selecciona Propiedades.
En Propiedades de configuración > C/C++ > Directorios de inclusión adicionales, agrega C:\wxWidgets-3.2.2.1\include y C:\wxWidgets-3.2.2.1\include\msvc.
En Propiedades de configuración > Vinculador > Directorios de bibliotecas adicionales, agrega C:\wxWidgets-3.2.2.1\lib\vc_x64_lib.
Abre wxWidgetsSample.cpp y reemplázalo con el siguiente código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")

#include <wx/wxprec.h>

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

class MyApp : public wxApp
{
public:
 virtual bool OnInit();
};

class MyFrame : public wxFrame
{
public:
 MyFrame();
private:
 void OnHello(wxCommandEvent& event);
 void OnExit(wxCommandEvent& event);
 void OnAbout(wxCommandEvent& event);
};

enum
{
 ID_Hello = 1
};

wxIMPLEMENT_APP(MyApp);

bool MyApp::OnInit()
{
 MyFrame* frame = new MyFrame();
 frame->Show(true);
 return true;
}

MyFrame::MyFrame()
 : wxFrame(NULL, wxID_ANY, "Hello World")
{
 wxMenu* menuFile = new wxMenu;
 menuFile->Append(ID_Hello, "&Hello...\tCtrl-H",
 "Help string shown in status bar for this menu item");
 menuFile->AppendSeparator();
 menuFile->Append(wxID_EXIT);
 wxMenu* menuHelp = new wxMenu;
 menuHelp->Append(wxID_ABOUT);
 wxMenuBar* menuBar = new wxMenuBar;
 menuBar->Append(menuFile, "&File");
 menuBar->Append(menuHelp, "&Help");
 SetMenuBar(menuBar);

 wxButton* button1 = new wxButton(this, ID_Hello, _("Hello"), wxPoint(20, 20), wxSize(100, 32));
 Connect(ID_Hello, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnHello));

 wxButton* button2 = new wxButton(this, wxID_ABOUT, _("About"), wxPoint(20, 60), wxSize(100, 32));
 Connect(wxID_ABOUT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnAbout));

 wxButton* button3 = new wxButton(this, wxID_EXIT, _("Exit"), wxPoint(20, 100), wxSize(100, 32));
 Connect(wxID_EXIT, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(MyFrame::OnExit));

 CreateStatusBar();
 SetStatusText("Welcome to wxWidgets!");
 Bind(wxEVT_MENU, &MyFrame::OnHello, this, ID_Hello);
 Bind(wxEVT_MENU, &MyFrame::OnAbout, this, wxID_ABOUT);
 Bind(wxEVT_MENU, &MyFrame::OnExit, this, wxID_EXIT);
}

void MyFrame::OnExit(wxCommandEvent& event)
{
 Close(true);
}

void MyFrame::OnAbout(wxCommandEvent& event)
{
 wxMessageBox("This is a wxWidgets' Hello world sample",
 "About Hello World", wxOK | wxICON_INFORMATION);
}

void MyFrame::OnHello(wxCommandEvent& event)
{
 wxLogMessage("Hello world from wxWidgets!");
}

Al compilar y ejecutar se abrirá una ventana como la siguiente.

Referencias

El proyecto de ejemplo se encuentra a continuación. wxWidgetsSample

Fin.

'Cómo generar la hora actual en formato ISO8601 en C++'

Sat, 15 Apr 2023 19:35:27 +0900

Requisitos

Estándar ISO C++ 20 (/std:c++20)

Código

1
2
3
4


#include <chrono>
#include <format>

std::string datetime = std::format("{:%FT%TZ}", system_clock::now());

Esta fue la forma de generar la hora actual en formato ISO8601 en C++.

Referencias

std::format

'【Por idioma】Resumen de entornos de ejecución de código en línea'

Sun, 09 Apr 2023 14:01:00 +0900

Python

Google Colaboratory

Google Colaboratory es un entorno de ejecución de Python en línea.

Permite el uso de GPU.
Los cuadernos de Colab permiten combinar código ejecutable y texto enriquecido (incluyendo imágenes, HTML, LaTeX, etc.) en un solo documento.

Está basado en Jupyter Notebook.

Rust

Rust Playground

JavaScript

Javascript Playground

Java

paiza.IO Online Java compiler

Haskell

Haskell Playground

Swift

Online Swift Playground

C++

C++ 14

Otros

AWS Cloud9

Entorno de desarrollo integrado en línea proporcionado por Amazon AWS. Viene preempaquetado con herramientas para más de 40 lenguajes de programación, como Node.js, JavaScript, Python, PHP, Ruby, Go y C++.

Visual Studio Code for the Web

Entorno de desarrollo en línea proporcionado por Microsoft. Sin embargo, no se puede ejecutar ni depurar código en lenguajes que requieren compilación.

paiza.IO

Entorno de ejecución en línea compatible con 24 lenguajes principales, como C, C++, Java, Ruby, Python, PHP y Perl.

CodePen

Entorno de ejecución en línea para HTML, CSS y JavaScript.

codeanywhere

IDE en línea. Permite compartir código y chatear.

Cómo tuitear usando la API de Twitter y Google Colaboratory

Sat, 08 Apr 2023 18:48:32 +0900

Lo que necesitas

API de Twitter
Twitter API SECRET
Twitter ACCESS TOKEN
Twitter ACCESS TOKEN SECRET
Cuenta de Google

Para obtener la API de Twitter, consulta los sitios de referencia.

Procedimiento para tuitear usando la API

Accede a https://colab.research.google.com/
Selecciona “Archivo” → “Nuevo cuaderno”
Pega y ejecuta el siguiente código (usa los valores reales que obtuviste)

1
2
3
4


API_KEY = '9Smu2f2RoLqbVQHQq6n79Z2JW'
API_SECRET = 'uGVRIkLL2l8sRyPv2Lr4mXxXppnQF1isMoRnvktcXCtFgAK2R8'
ACCESS_TOKEN = '0367292979164670705-7hSErDoQbO6fkFtnn5UY0vqpvecy0O'
ACCESS_TOKEN_SECRET = 'pUv81U9GVzZirz5g4AxZPHAJ4GpSXnBo8GUcZ1egtjw9q'

Pega y ejecuta el siguiente código

1

import tweepy

Pega y ejecuta el siguiente código (API v1.1)

1
2
3
4


auth = tweepy.OAuthHandler(API_KEY, API_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = tweepy.API(auth)
api.update_status("hello")

→ Se publicará el tuit hello

Pega y ejecuta el siguiente código (API v2.0)

1
2


client = tweepy.Client(consumer_key=API_KEY, consumer_secret=API_SECRET, access_token=ACCESS_TOKEN, access_token_secret=ACCESS_TOKEN_SECRET)
client.create_tweet(text='hello v2')

→ Se publicará el tuit hello v2

Eso es todo.

Referencias

Cómo compilar OpenSSL en Windows

Fri, 07 Apr 2023 21:06:32 +0900

¿Qué es OpenSSL?

Es una biblioteca de código abierto que proporciona el procesamiento necesario para realizar comunicaciones cifradas.

Para utilizarlo desde un programa, dado que el código fuente en lenguaje C es público, es necesario compilarlo para crear la biblioteca.

A continuación se presentan los pasos para su compilación.

Preparación del entorno de compilación

Perl

Descargue strawberry-perl-5.32.1.1-64bit.msi desde https://strawberryperl.com/. Creo que está bien usar la última versión.
NASM

Descargue 2.16.01/nasm-2.16.01-win64.zip desde la sección de Download en https://www.nasm.us/. Creo que está bien usar la última versión (que no sea rc). Después de la instalación, es necesario registrar la carpeta donde se instaló NASM en la variable de entorno PATH.
Visual Studio 2022 ** o ** Build Tools for Visual Studio 2022

Instale Visual Studio 2022 Community o Build Tools for Visual Studio 2022 desde https://visualstudio.microsoft.com/ja/downloads/.

Pasos para compilar OpenSSL en Windows

Descargue y extraiga openssl-3.1.0.tar.gz desde https://www.openssl.org/source/. Si no puede extraerlo, ejecute tar -xzf openssl-3.1.0.tar.gz en el símbolo del sistema.
Inicie el símbolo del sistema con privilegios de administrador.
Abra la carpeta extraída.
Ejecute el siguiente comando. * Cambie la parte de Community según la versión de Visual Studio que haya instalado:

1

"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64

Ejecute el siguiente comando:

1

perl Configure VC-WIN64A

Ejecute el siguiente comando (toma bastante tiempo):

1

nmake

Ejecute el siguiente comando (toma bastante tiempo):

1

nmake test

Ejecute el siguiente comando:

1

nmake install

Si todo sale bien, OpenSSL se instalará en C:\Program Files\OpenSSL.

Eso es todo.

Referencias

https://ja.wikipedia.org/wiki/OpenSSL

Cómo crear presentaciones con HTML (reveal.js)

Thu, 06 Apr 2023 23:23:46 +0900

Cómo crear presentaciones con HTML

reveal.js es una herramienta para crear presentaciones utilizando HTML y Markdown, que incluye las siguientes características:

Variadas funciones de presentación, como fórmulas matemáticas, animaciones y operaciones de deslizamiento (swipe).
Permite personalizar temas y diseños.
Funciones de navegación compatibles con múltiples dispositivos, como ratones, teclados y paneles táctiles (touchpads).
Ofrece funciones avanzadas, como reproducción automática de diapositivas e incrustación de vídeos.
Permite exportar en formato PDF.

Gracias a estas funciones, los usuarios pueden crear fácilmente presentaciones interactivas y atractivas.

Instalación y uso de reveal.js

La forma más sencilla de utilizarlo es descargar el archivo ZIP completo desde la siguiente página y descomprimirlo.

Abre https://revealjs.com/installation y descarga el master.zip desde el enlace.
Abre el archivo index.html de la carpeta descomprimida en un navegador.
Edita el archivo index.html para crear tu propia presentación.

Como referencia, en demo.html encontrarás código HTML de demostración.

Casos de uso

Las presentaciones creadas pueden publicarse directamente como páginas web o exportarse como PDF. Además, dado que el código fuente de la presentación es texto, resulta fácil gestionarlo mediante sistemas de control de versiones.

Al parecer, también es posible crear presentaciones en formato Markdown.

Referencias

Cómo generar imágenes de ilustraciones usando IA (Stable Diffusion)

Thu, 06 Apr 2023 00:43:19 +0900

¿Qué es Stable Diffusion?

Stable Diffusion es una IA que genera imágenes a partir de información de texto (texto a imagen), desarrollada por un equipo de investigación de la Universidad de Múnich, Alemania. Al entrenar con diversas imágenes, puede generar una amplia variedad de imágenes, desde fotografías realistas hasta ilustraciones.

En esta ocasión, presentaré cómo generar imágenes de ilustraciones utilizando datos preentrenados de Stable Diffusion.

Lo que necesitas

Una cuenta de Google

Solo eso.

Procedimiento de generación

Abre https://colab.research.google.com
En la esquina superior izquierda, selecciona Archivo y luego Nuevo cuaderno
Selecciona Editar y luego Configuración del cuaderno
Cambia el Acelerador de hardware a GPU
Pega y ejecuta el siguiente código

1

!pip install diffusers==0.8.0 transformers

Pega y ejecuta el siguiente código

1

from diffusers import StableDiffusionPipeline

Pega y ejecuta el siguiente código

1
2


pipe = StableDiffusionPipeline.from_pretrained("gsdf/Counterfeit-V2.5")
pipe.to("cuda")

Pega y ejecuta el siguiente código

1
2
3
4
5


prompt = "((masterpiece,best quality)),1girl, solo, animal ears, rabbit, barefoot, knees up, dress, sitting, rabbit ears, short sleeves, looking at viewer, grass, short hair, smile, white hair, puffy sleeves, outdoors, puffy short sleeves, bangs, on ground, full body, animal, white dress, sunlight, brown eyes, dappled sunlight, day, depth of field"
n_prompt = "EasyNegative, extra fingers,fewer fingers"

image = pipe(prompt, negative_prompt = n_prompt).images[0]
image

El Prompt utilizado aquí está basado en el Prompt de https://huggingface.co/gsdf/Counterfeit-V2.5.

Resultados generados (algunos)

Referencias

Cómo actualizar rustc

Sat, 18 Mar 2023 10:27:02 +0900

Cómo actualizar rustc

Simplemente ejecuta la siguiente línea en la línea de comandos.

1

rustup update

Ejemplo de salida

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


rustup update
info: syncing channel updates for 'stable-x86_64-pc-windows-msvc'
warning: Signature verification failed for 'https://static.rust-lang.org/dist/channel-rust-stable.toml'
info: latest update on 2023-03-09, rust version 1.68.0 (2c8cc3432 2023-03-06)
info: downloading component 'rust-src'
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
info: downloading component 'rust-std'
info: downloading component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 37.5 MiB/s in 1s ETA: 0s
info: downloading component 'rustfmt'
info: removing previous version of component 'rust-src'
info: removing previous version of component 'cargo'
info: removing previous version of component 'clippy'
info: removing previous version of component 'rust-docs'
info: removing previous version of component 'rust-std'
info: removing previous version of component 'rustc'
info: removing previous version of component 'rustfmt'
info: installing component 'rust-src'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 19.4 MiB / 19.4 MiB (100 %) 2.4 MiB/s in 6s ETA: 0s
info: installing component 'rust-std'
 27.6 MiB / 27.6 MiB (100 %) 12.7 MiB/s in 2s ETA: 0s
info: installing component 'rustc'
 63.9 MiB / 63.9 MiB (100 %) 13.8 MiB/s in 4s ETA: 0s
info: installing component 'rustfmt'
info: checking for self-updates
info: downloading self-update

 stable-x86_64-pc-windows-msvc updated - rustc 1.68.0 (2c8cc3432 2023-03-06) (from rustc 1.64.0 (a55dd71d5 2022-09-19))

info: cleaning up downloads & tmp directories

'Características de Rust'

Mon, 03 Oct 2022 22:47:20 +0900

Características de Rust

Es un lenguaje de programación de código abierto relativamente nuevo desarrollado por Mozilla.
Es un lenguaje rápido y especializado en programación de sistemas, sin recolección de basura.
Garantiza la seguridad de la memoria con un mecanismo único de propiedad (ownership) y préstamo (borrowing) como parte de las especificaciones del lenguaje.
Funciona de forma multiplataforma.
Incluye de manera predeterminada un excelente administrador de paquetes llamado Cargo.

Mostrar una ventana simple en Rust

Sat, 01 Oct 2022 19:08:58 +0900

Mostrar una ventana simple en Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "win"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies.winapi]
version = "0.3"
features = ["winuser"]

El código fuente es el siguiente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


#![windows_subsystem = "windows"]
use winapi::{
 um::{
 winuser::{RegisterClassW, WNDCLASSW, CS_HREDRAW, CS_VREDRAW,
 LoadIconW, IDI_APPLICATION, LoadCursorW, IDC_ARROW,
 CreateWindowExW, ShowWindow, SW_NORMAL, UpdateWindow,
 GetMessageW, TranslateMessage, DispatchMessageW, MSG,
 WM_DESTROY, PostQuitMessage, DefWindowProcW, WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT},
 wingdi::{GetStockObject, WHITE_BRUSH},
 },
 shared::{
 windef::{HWND, HBRUSH},
 minwindef::{UINT, WPARAM, LPARAM, LRESULT},
 },
};
use std::ptr;
use std::mem;

fn main() {
 unsafe {
 let class_name = encode("my_window_class_name");
 if !register_wndclass(&class_name) {
 return;
 }
 let hwnd = create_window(&class_name);
 if hwnd.is_null() {
 return;
 }
 ShowWindow(hwnd, SW_NORMAL);
 UpdateWindow(hwnd);
 let mut msg = mem::uninitialized::<MSG>();
 loop {
 if GetMessageW(&mut msg, ptr::null_mut(), 0, 0) == 0 {
 return;
 }
 TranslateMessage(&mut msg);
 DispatchMessageW(&mut msg);
 }
 }
}

fn encode(source: &str) -> Vec<u16> {
 source.encode_utf16().chain(Some(0)).collect()
}

unsafe fn register_wndclass(class_name: &[u16]) -> bool {
 let mut winc = mem::zeroed::<WNDCLASSW>();
 winc.style = CS_HREDRAW | CS_VREDRAW;
 winc.lpfnWndProc = Some(win_proc);
 winc.hIcon = LoadIconW(ptr::null_mut(), IDI_APPLICATION);
 winc.hCursor = LoadCursorW(ptr::null_mut(), IDC_ARROW);
 winc.hbrBackground = GetStockObject(WHITE_BRUSH as i32) as HBRUSH;
 winc.lpszClassName = class_name.as_ptr();
 RegisterClassW(&winc) > 0
}

unsafe fn create_window(class_name: &[u16]) -> HWND {
 CreateWindowExW(
 0,
 class_name.as_ptr(),
 encode("Hello, World!").as_ptr(),
 WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 ptr::null_mut(),
 )
}

unsafe extern "system" fn win_proc(hwnd: HWND, msg: UINT, w_param: WPARAM, l_param: LPARAM) -> LRESULT {
 match msg {
 WM_DESTROY => PostQuitMessage(0),
 _ => return DefWindowProcW(hwnd, msg, w_param, l_param),
 };
 0
}

Referencia

Programación de Windows en Rust - Edición CreateWindow

Escribiendo pruebas en Rust

Sat, 01 Oct 2022 02:00:59 +0900

Para escribir pruebas en Rust, crea una función añadiendo el atributo #[test] en la línea superior de la definición de la función de prueba.

1
2
3
4
5
6
7
8


fn plus(a:i32,b:i32)->i32 {
 a+b
}

#[test]
fn plus_test() {
 assert_eq!(plus(1, 1), 2);
}

El código de prueba se puede ejecutar con cargo test. Si la prueba tiene éxito, se imprimirá ok. Si falla, se imprimirá FAILED.

En caso de éxito

1
2
3
4
5
6
7
8
9


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.35s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

En caso de fallo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


C:\Users\admin\Desktop\test1>cargo test
 Compiling test1 v0.1.0 (C:\Users\admin\Desktop\test1)
 Finished test [unoptimized + debuginfo] target(s) in 0.33s
 Running unittests src\main.rs (target\debug\deps\test1-be5d3118bc52cb3a.exe)

running 1 test
test plus_test ... FAILED

failures:

---- plus_test stdout ----
thread 'plus_test' panicked at 'assertion failed: `(left == right)`
 left: `2`,
 right: `3`', src\main.rs:7:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
 plus_test

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass '--bin test1'

Mostrar un MessageBox en Rust

Fri, 30 Sep 2022 23:54:31 +0900

Puede mostrar un MessageBox en Rust siguiendo los pasos a continuación.

Instalar Rust. Consulte Cómo empezar con Rust.
Ejecute cargo new --bin MessageBox en el símbolo del sistema.
Vaya al directorio MessageBox.
Abra Cargo.toml y modifíquelo de la siguiente manera.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
winapi = "0.2.7"
user32-sys = "0.2.0"

Abra src\main.rs y modifíquelo de la siguiente manera.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


extern crate user32;
extern crate winapi;

use std::ffi::CString;
use user32::MessageBoxA;
use winapi::winuser::{MB_OK, MB_ICONINFORMATION};

fn main() {
 let lp_text = CString::new("Hello, world!").unwrap();
 let lp_caption = CString::new("MessageBox Example").unwrap();

 unsafe {
 MessageBoxA(
 std::ptr::null_mut(),
 lp_text.as_ptr(),
 lp_caption.as_ptr(),
 MB_OK | MB_ICONINFORMATION
 );
 }
}

Ejecute cargo run en el símbolo del sistema.
Para compilar una versión de lanzamiento, ejecute cargo build --release.

Referencia

Hello World MesssageBox example in Rust

Enumeración de títulos de ventanas

Tue, 20 Sep 2022 17:03:15 +0900

Enumeración de títulos de ventanas

Este es el método para enumerar los títulos de las ventanas actualmente abiertas usando PowerShell.

1

Get-Process|where{$_.mainWindowTItle}|Select-Object MainWindowTitle

Ejemplo de salida

1
2
3
4
5
6
7
8
9


MainWindowTitle
---------------
Windows PowerShell
Internet Explorer
Sin título - Paint
Sin título - Bloc de notas
Administrador de tareas
Experiencia de entrada de Windows
Documento - WordPad

Eliminar .DS_Store por lotes con PowerShell

Mon, 12 Sep 2022 10:11:42 +0900

Navega al directorio de destino y ejecuta el siguiente comando para eliminar de forma masiva los archivos .DS_Store, incluyendo los de las subcarpetas.

1

Get-ChildItem . -include '.DS_Store' -Recurse -Force | Remove-Item -Force

Cómo instalar Go

Sat, 10 Sep 2022 00:48:17 +0900

Introducción

Go es un lenguaje de programación relativamente nuevo publicado por Google en 2009. El compilador, las herramientas y las bibliotecas de Go se publican como código abierto. Además, Go es un lenguaje de tipado estático como C y Java, pero es un lenguaje que no utiliza punteros como el lenguaje C.

Método de instalación

Instalar Go

Desde el sitio anterior, se publican instaladores para cada plataforma.

Siga la pantalla para proceder con la instalación.

La instalación se ha completado. Es fácil, ¿verdad?

Primer programa

Guarde el siguiente programa como hello.go.

1
2
3
4
5
6
7


package main

import "fmt"

func main() {
 fmt.Printf("Hello World\n")
}

Al ejecutar go run hello.go desde el símbolo del sistema o la terminal, se mostrará Hello, world!.

Si desea compilarlo, al ejecutar go build hello.go, se generará hello.exe. Al ejecutar hello.exe, se mostrará Hello, world!.

También puede ejecutar código en la página web

https://go.dev/play/

Documentación en japonés

http://go.shibu.jp/

Las explicaciones necesarias para aprender Go están concentradas en el enlace anterior (versión traducida al japonés). Dado que la tecnología relacionada con Go es abierta, es tan completa que no es necesario comprar textos en papel.

¡Entonces, que disfrutes de tu vida con Go!

'Enumerando números primos en Rust'

Fri, 09 Sep 2022 07:08:49 +0900

He escrito un programa para enumerar números primos en Rust.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}

Cómo empezar con Rust

Tue, 06 Sep 2022 00:12:36 +0900

Introducción

Rust es un lenguaje de programación relativamente nuevo que permite escribir módulos rápidos y eficientes en el uso de la memoria con una sintaxis moderna. Es compatible con múltiples plataformas y se utiliza en mundos como WebAssembly y sistemas embebidos. Como ejemplos famosos, es utilizado por Firefox, DropBox y Cloudflare.

También está llamando la atención como una alternativa a C++.

Método de instalación

Instalar Rust

En el sitio mencionado anteriormente se publican los métodos de instalación para cada plataforma.

Primer programa

Guarde el siguiente programa como main.rs.

1
2
3


fn main() {
 println!("Hello, world!");
}

Al ejecutar rustc main.rs desde el símbolo del sistema o la terminal, se compilará, y al ejecutar ./main (main.exe en el caso de Windows), se imprimirá Hello, world!.

Documentación en japonés

The Rust Programming Language Versión Japonesa

Las explicaciones necesarias para aprender Rust están recopiladas en el enlace anterior (versión traducida al japonés). Es tan completo que no hay necesidad de comprar un libro de texto de Rust.

Si desea probarlo en la Web

Si desea probarlo en la Web sin instalar un compilador, puede utilizar The Rust Playground. Al ingresar el código y presionar el “botón de ejecución”, se compilará y ejecutará en la Web.

Programación on kenji.blog

Qué hacer cuando no puedes cancelar Google One (Gemini)

[Atención] ¿Se te cobrará cuando termine la prueba gratuita de Gemini? Resumen de cómo cancelar

¿Qué pasa cuando termina la prueba gratuita?

Si cancelas, no se te cobrará, pero…

¡El método de cancelación correcto está aquí!

Resumen

Cómo eliminar de forma masiva metadatos (información personal) de Excel, Word, etc. con PowerShell

Cómo eliminar de forma masiva metadatos (información personal) de Excel, Word, etc. con PowerShell

1. Eliminar los metadatos de un solo archivo de Excel

2. Procesar todos los archivos de Excel en una carpeta en masa

3. Eliminar metadatos de otros archivos de Office (Word / PowerPoint)

Para Word

Para PowerPoint

Resumen

Pasos para llamar a TinyLLaMA desde C++ (usando llama.cpp)

✅ Configuración de TinyLLaMA × C++ (usando llama.cpp)

🔧 Paso 1: Preparar llama.cpp

1-1. Entorno necesario (mínimo)

1-2. Obtener y compilar llama.cpp

📦 Paso 2: Descargar y convertir el modelo TinyLLaMA

2-1. Obtener el modelo original de HuggingFace

2-2. Convertir al formato GGUF (para llama.cpp)

2-3. Cuantización del modelo (reducción de tamaño)

🧪 Paso 3: Llamar al modelo desde C++ (Ejemplo de código)

3-1. Código C++ simple (Inferencia)

🧱 Paso 4: Método de compilación (Ejemplo)

✅ Ejemplo de estructura del producto final (Organizado)

🧠 Notas adicionales para aplicar a tu caso de uso

📌 Resumen

Ventajas y desventajas de crear programas con Win32API + C++

Atractivo y desafíos de desarrollar con Win32API + C++

Ventajas

Ejecución nativa ultrarrápida

Alta flexibilidad y libertad

Fácil de distribuir sin necesidad de tiempo de ejecución

Se pueden crear aplicaciones ligeras

Control avanzado a nivel de sistema operativo posible

Desventajas

Baja eficiencia de desarrollo

La mantenibilidad tiende a disminuir

El soporte para UI moderna es tedioso

No soporta multiplataforma

El costo de aprendizaje es extremadamente alto

Usos adecuados

Usos no adecuados

Resumen de evaluación

Conclusión

FizzBuzz

¿Qué es FizzBuzz, al final de cuentas?

¿Es verdad que “si no puedes escribir FizzBuzz, no sirves como programador”?

No se trata de si puedes hacerlo, sino de si estás en el “estado” para hacerlo

La trampa del típico consejo “solo entrénate y estarás bien”

A pesar de todo, FizzBuzz también es un buen problema

En conclusión

La Torre de Hanói

La Torre de Hanói

¿Qué es La Torre de Hanói?

Resolvamos la Torre de Hanói en Python

¿Cuánto tiempo se tarda en mover 64 discos?

Resumen

Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI

🎯 Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI (Visual Studio 2022 / C++)

✅ Arquitectura general

🔹 ① DLL envoltura CLI (C++/CLI)

🔹 ② Lado de llamada C++ nativo

🔧 Paso 1: Creación del proyecto de la DLL envoltura CLI

1. Creación del proyecto

2. Añadir paquete NuGet

3. Implementación del código en el lado CLI

PowerShellWrapper.h

PowerShellWrapper.cpp

🔧 Paso 2: Llamada desde el lado de C++ nativo

1. Crear proyecto de aplicación de consola C++

2. Configurar referencias

3. Código de ejecución (main.cpp)

💡 Nota adicional (IDL / TLB / Registro COM)

✅ Estructura final

Procedimiento de restauración de software (inicialización/reparación) para dispositivos Android (Google Pixel)

Procedimiento de restauración para dispositivos Android (Google Pixel)

✅ Configuración de TinyLLaMA × C++ (usando `llama.cpp`)

2-2. Convertir al formato GGUF (para `llama.cpp`)