|
PowerRustCOBOL
3 Archivos Adjunto(s)
Lo que comenzó como una simple experimentación se está transformando en un pequeño proyecto capaz de entregar cierto valor. Todavía está muy crudo, pero es bastante prometedor.
Utilicé Claude Code para imaginar una versión modernizada de PowerCobol 3.0. En lugar de intentar reutilizar código existente, imaginé cómo sería un PowerCobol que mantuviera en gran parte la filosofía del Fujitsu PowerCobol 3.0: sin ActiveX, sin dependencias del Registro de Windows, y con soporte para actividades modernas (llamar APIs REST, poseer un Agente de Inteligencia Artificial integrado capaz de modificar los propios objetos del formulario), todo ello con una interfaz moderna al estilo Apple Liquid Glass de los nuevos iPhones. No utilicé el modelo de programación de Fujitsu (Nested programs), aunque quizás lo incorpore más adelante. Opté por algo más simple: un formulario = un programa. El enlace de eventos de un botón, timer o cualquier objeto sería un párrafo (generado por la IDE y editable por el desarrollador), de modo que todos los objetos convivieran dentro del mismo código. Agregué una gran cantidad de controles (date picker, grid, imágenes, vídeos, elementos geométricos, botones, labels, textbox multilínea, listboxes, etc.). No está listo todavía para uso en producción, pero quise compartirlo desde ya para recibir opiniones sobre qué funcionalidades sería interesante añadir. Gasté pocas horas describiendo lo que quería. Toda la programación fue realizada por Claude Code utilizando Rust, un lenguaje moderno y extremadamente rápido que está siendo considerado para reemplazar el kernel de Linux. Rust interpreta y ejecuta el código COBOL sin problemas. Creo que lo más interesante es ver cómo los servicios de codificación con Inteligencia Artificial Generativa están cambiando completamente la forma de trabajar. Además del timer tradicional de PowerCOBOL, también añadí un objeto para realizar llamadas a APIs (REST) y soporte completo a Generative AI Agents. Un agente es capaz de simular cualquier comportamiento que deseemos. Por ejemplo: Defina una tool capaz de calcular la diferencia entre dos fechas definidas como PIC 9(8) (DDMMYYYY). Cuando solicite SET days TO agent::run('Calcule la diferencia entre "data-item1" y "data-item2"'), el agente retorna el resultado en formato PIC 9(8). En realidad, cualquier cosa que podamos imaginar es posible solicitarle al agente. Por ejemplo: analice los ítems de la tabla valores-por-mes y haga una predicción del valor del próximo mes, colocando el resultado en el ítem de datos valor-del-proximo-mes. ¡Listo! Esto es todo lo que se necesita para crear subrutinas dinámicamente. Imagina todo lo que se puede hacer con esta capacidad... Aún no tengo un plazo definido para liberar una versión testable. Claude es caro y mi plan actual se agota muy rápidamente, necesitando algunas horas para poder continuar. No pretendo cobrar por el uso de la solución, pero sería muy interesante si pudieran contribuir para contratar una suscripción más robusta que acelere el desarrollo. No doy garantías, ni pretendo dar soporte, ni garantizo que la solución funcione perfectamente. Simplemente es un hobby mío y no quiero tener que lidiar con el dolor de cabeza de dar soporte a un producto que, por más interesante que sea, no tiene razón de existir. El mercado de IDEs nunca volverá a ser el mismo, con cada vez menos desarrollo siendo realizado de forma artesanal como hacíamos hasta hace pocos años, precisamente por causa de la tecnología que está posibilitando crear este proyecto (Inteligencia Artificial Generativa). |
@Eslopes, estás haciendo realidad mi sueño de hace años !
¡¡¡MUY interesante la iniciativa!!! ¿Qué compilador has escogido para código Cobol? En cuanto a Claude IA, cuáles son las tarifas ? El foro tiene una cuenta PayPal, podríamos organizar donaciones, lo que podamos (la verdad es que no sé cuáles son las tarifas), y luego enviártelo. |
Re: PowerRustCOBOL
Hola Kuk,
Gracias por tu mensaje. Claude fue utilizado para crear en RUST el cobol-parser, que es principalmente compatible con COBOL-85 (ANSI X3.23-1985). Maneja el conjunto completo de características de COBOL-85: terminadores de ámbito (END-IF, END-EVALUATE, END-PERFORM, END-CALL), EVALUATE/WHEN/WHEN OTHER, PERFORM UNTIL/VARYING, INSPECT/TALLYING/REPLACING, las cuatro DIVISIONes y sus SECTIONs, además de los verbos estándar de E/S de archivos (READ, WRITE, REWRITE, DELETE, START). El parser no implementa las extensiones orientadas a objetos de COBOL 2002, los intrínsecos XML/JSON de COBOL 2014, ni CONTINUE FROM. Además del estándar, añade tres extensiones específicas de COBOL 2002: INVOKE para llamadas a métodos de controles de formulario, bloques EXEC RUST … END-EXEC para Rust inline, y la sintaxis :: para acceso a propiedades. El costo de Claude Code ronda los US$ 200/mes. Para el primer mes, este valor es suficiente para cubrir el 80% del trabajo. Posteriormente, solo se necesitarán alrededor de US$ 100 por mes durante un período que puede oscilar entre 3 y 6 meses. Mi suscripción actual solo permite algunas pocas interacciones cada 4 o 5 horas. Me gustaría limitar las contribuciones a US$ 10,00 por persona. No considero justo que una sola persona contribuya y que todos tengan acceso gratuito. Mi plan es, inicialmente, liberar el código solo para quienes contribuyan en esta fase. Cuando alcancemos la versión 1.0, podremos liberarlo a la comunidad sin costo. El proyecto puede ser una forma de liberar a la comunidad de las garras de los productores de código. Pretendo incluir varios recursos que hoy no están disponibles en ningún compilador COBOL, por ejemplo, la posibilidad de que el mismo código funcione en MacOS, Windows y Linux, con la misma interfaz. No existen dependencias externas ni legado que estemos cargando (ActiveX, Registry, frameworks, etc.). El compilador ya acepta EXEC RUST. En el futuro implementaré EXEC HTML, EXEC Javascript, EXEC Python y otros, soporte XML/JSON, además de algunos aceleradores para el uso de bases de datos, creación automática de formularios, etc. Cita:
|
@Eslopes, voy a notificar a todos los usuarios, a ver si la gente se anima. Además, limitando la aportación a 10$ (o €), creo que es una cantidad que muchos se pueden permitir. Yo voy a participar seguro.
He oído algo sobre Rust, pero nunca lo he tocado. Entonces el binario que se produce, proviene del código Rust que es producto de código Cobol parseado (traducido), es correcto? |
El COBOL IDE y el COBOL Form Designer son binarios. El código COBOL resultante actualmente es interpretado por un runtime de COBOL creado por Claude.
Todavía estoy probando lo básico (dibujar un formulario, responder a eventos, etc.). Voy a verificar el rendimiento y ver qué es necesario para obtener el desempeño máximo. Probablemente tendremos una generación de bytecode en tiempo de compilación y generación de código nativo en tiempo de interpretación, obteniendo la máxima portabilidad del código compilado y el máximo rendimiento del código en ejecución. ¡Saludos! Cita:
|
Re: PowerRustCobol - version 0.0.1 (beta)
COBOL IDE — Registro de Cambios (Changelog)
Reglas de Versionado
[hr] [0.0.1] — 2026-05-29 (versión inicial etiquetada) Fundación (pre-etiqueta, post-parser) Todo el trabajo que aparece a continuación se completó antes de aplicar la etiqueta 0.0.1. Se cataloga aquí como el conjunto base de características. Runtime y Toolchain
IDE Shell (cobol-ide)
Diseñador de Formularios
Recursos en Implementación
Otros cambios Se renombraron los identificadores COBOLT-* a COBOL-* en todo el código. Tengo que reconocer que los japoneses fueron geniales, hace 35 años, cuando crearon el PowerCOBOL. Empecé con un concepto simple: un formulario, un programa. Pero pronto comencé a encontrar dificultades en la organización del código, además de conflictos con nombres de variables y un aumento exponencial de la complejidad del código final. Decidí dar un paso atrás y utilizar programas anidados, exactamente como lo hacía el añorado PowerCOBOL. El código quedó más limpio y el modelo está generando código de manera mucho más fácil. El resultado final se acerca conceptualmente al Power, aunque mantiene una buena distinción, además de ser infinitamente superior en términos de recursos. Aun así, me quito el sombrero ante los diseñadores de Japón. ¡Hicieron un trabajo excelente y primoroso! COBOL IDE — Registro de Cambios (Changelog) [1.0.0] — 2026-05-29 Major — Arquitectura de programas anidados (modelo Opción C de PowerCOBOL) Esta es la primera actualización importante de versión. Todo el modelo de generación de código y almacenamiento de formularios ha sido rediseñado para coincidir con el enfoque de Fujitsu PowerCOBOL 3.0: cada manejador de eventos se convierte en un programa anidado COBOL-85; el archivo .cfrm es la única fuente de verdad; el archivo .cbl generado es un artefacto de compilación que el usuario nunca edita. Formato de archivo .cfrm (v1.0 — carga compatible con versiones anteriores) Se añadieron tres nuevas secciones XML al archivo .cfrm: [*] <working-storage><![CDATA[...]]></working-storage> — declaraciones de datos COBOL en bruto emitidas literalmente en la WORKING-STORAGE del programa exterior; soporta cláusulas GLOBAL y EXTERNAL para compartir datos a nivel de formulario y entre formularios. [*] <form-events> — manejadores de ciclo de vida OnLoad y OnClose almacenados como elementos hijos <Event> con cuerpos CDATA. [*] <deleted-controls> — papelera de reciclaje: el código de eventos de controles eliminados se conserva aquí (nunca se emite al .cbl) para poder restaurarlo posteriormente. Los elementos <Event> ahora utilizan formato de inicio/fin con cuerpo CDATA para las sentencias COBOL del usuario. Las etiquetas antiguas de autocierre <Event .../> todavía se cargan correctamente (el código estará vacío). Cambios en el modelo (cobol-forms) [*] EventBinding gana el campo code: String — sentencias COBOL en bruto para este manejador. [*] EventBinding::for_control(ctrl_id, event) — deriva automáticamente el nombre del párrafo como "CTRL-ID--EVENT-NAME" (separador de doble guion). [*] EventBinding::has_code(), code_line_count() — funciones auxiliares para la interfaz de usuario. [*] derive_paragraph_name(ctrl_id, event) -> String — función de utilidad pública. [*] Form gana los campos: user_ws_source: String, form_events: Vec<EventBinding>, deleted_code: Vec<DeletedControlCode>. [*] Form::new() pre-popula form_events con stubs vacíos de OnLoad / OnClose. [*] Form::recycle_control(id, timestamp) — mueve el código de eventos a la papelera de reciclaje antes de eliminar; restore_from_recycle(timestamp, target_id) lo recupera. [*] Form::control_has_code(id) — devuelve [(event, line_count)] para el diálogo de la interfaz. [*] Control::ensure_event(event) — vinculación idempotente de evento con nombre derivado automáticamente. [*] Estructura DeletedControlCode — control_id, deleted_at (marca de tiempo ISO), events. Panel de Propiedades (cobol-ide) [*] La sección "Event Bindings" fue reemplazada por una sección de solo lectura "Events" que muestra puntos de estado ●/○ y conteo de líneas por evento soportado; el usuario es dirigido a la Vista de Código para editar. [*] Se eliminó la sección "COBOL Paragraphs" de los controles de gráficos (fue reemplazada por la Vista de Código). [*] Se eliminaron los campos de preparación new_ev_name / new_ev_para del PropertiesPanel. Generación de Código (cobol-codegen) — Fase 3 (pendiente) La reescritura de PROCEDURE DIVISION para emitir programas anidados es el siguiente paso. Runtime (cobol-runtime) — Fase 4 (pendiente) La herencia de ámbito GLOBAL y el envío de programas anidados es el siguiente paso. Panel Vista de Código del IDE — Fase 5 (pendiente) Navegador de eventos + editor COBOL por evento es el siguiente paso. [hr] [0.2.2] — 2026-05-29 Corrección — Chart SET-TABLE genera COBOL inválido cuando DataSource/DataCount no están configurados La función write_chart_stubs() utilizaba .map().unwrap_or_else(fallback) para establecer valores predeterminados vacíos para las propiedades DataSource / DataCount, pero si la propiedad existía como cadena vacía Some(""), unwrap_or_else nunca se ejecutaba. El resultado era código COBOL generado inválido: ```cobol MOVE TO WS-LIN-13-SELECTED-IDX *> missing source CALL "COBOL-CHART-SET-TABLE" USING "LIN-13" *> missing args |
Progresso...
1 Archivos Adjunto(s)
PowerRustCOBOL — Registro de cambios
[2.1.0] — 2026-05-30 Fase 7 — Depurador El IDE ahora cuenta con un depurador interactivo completo para programas COBOL. Nuevo: tipos de canal DebugCmd y DebugEvent (cobol-runtime/src/debugger.rs) Dos enums tipados cruzan el límite de hilo entre el IDE y el intérprete: DebugCmd — Continue, StepOver, Pause — enviado desde el IDE al intérprete para controlar la ejecución. DebugEvent — Paused { line, col, paragraph, vars }, Resumed, Finished — enviado desde el intérprete de vuelta al IDE. Breakpoints (Arc<Mutex<HashSet<u32>>>) — conjunto compartido y seguro para hilos con los números de línea de breakpoints activos, escrito por el IDE y leído por el intérprete. Actualizado: Interpreter — hook de depuración por sentencia Interpreter::new_with_debug_channels() es un nuevo constructor que conecta los canales de depuración al intérprete. Antes de cada sentencia, exec_stmts() ahora llama a debug_check(), que: Extrae la línea fuente de la sentencia mediante Stmt::span(). Comprueba si la línea coincide con un breakpoint o si debug_stepping es verdadero, en modo StepOver. Si se cumple una condición de pausa, envía DebugEvent::Paused con una captura completa de variables (CobolEnvironment::iter() → lista VarSnapshot) y bloquea en debug_cmd_rx.recv() hasta que el IDE envíe Continue o StepOver. Un comando asincrónico Pause se gestiona mediante una consulta no bloqueante try_recv() en cada sentencia cuando aún no está pausado. DebugEvent::Finished se envía cuando run() termina normalmente o mediante STOP RUN. current_paragraph se actualiza al entrar en cada párrafo, de modo que el evento Paused siempre lleva el nombre correcto del párrafo. Nuevo: DebugRunner (cobol-ide/src/runner.rs) DebugRunner es un componente hermano de Runner que gestiona una sesión de depuración: start(file_name, source) — ejecuta todo el flujo lex → parse → semantic y luego lanza Interpreter::new_with_debug_channels() en un hilo en segundo plano. send_cmd(DebugCmd) — reenvía un comando de paso, continuación o pausa al hilo. drain_events() -> Vec<DebugEvent> — recopila los eventos de depuración pendientes en cada frame. drain_run() -> Vec<RunMsg> — recopila los mensajes de ejecución pendientes, incluidos diagnósticos, salida y finalización. pub breakpoints: Breakpoints — el IDE escribe aquí las líneas de breakpoint antes de llamar a start(); el puntero compartido se pasa directamente al intérprete. stop() — descarta cmd_tx, lo que desbloquea cualquier recv() en el intérprete y causa Err(_) → StopRun; luego une el hilo. Nuevo: panel lateral del depurador (cobol-ide/src/panels/debugger.rs) DebuggerPanel se renderiza en un panel lateral derecho redimensionable mientras una sesión de depuración está activa: Barra de pasos — ▶ Continue (F5), ⤵ Step Over (F10), ⏸ Pause. Los botones se deshabilitan cuando el intérprete está ejecutándose, es decir, no pausado. Indicador de ubicación — nombre del párrafo y línea fuente, con indicador de estado codificado por color: ● Running / ● Paused. Tabla de observación de variables — muestra todos los elementos de datos de CobolEnvironment en una cuadrícula rayada de dos columnas, nombre / valor, con búsqueda mediante un cuadro de filtro. Nuevo: gutter de breakpoints en editor.rs La columna de números de línea del editor de código ahora es un gutter de breakpoints totalmente interactivo: Al hacer clic en cualquier número de línea se alterna un círculo rojo de breakpoint (●) en esa línea. Cuando el depurador pausa, una flecha amarilla (→) y una fila resaltada marcan la línea de ejecución actual. EditorPanel::breakpoints: HashMap<PathBuf, HashSet<u32>> almacena breakpoints activos por archivo. breakpoints_for(path) devuelve el conjunto de líneas para un archivo dado, usado por do_debug() para inicializar los Breakpoints compartidos antes de iniciar la sesión. Nuevo: botón 🐛 Debug en la barra de herramientas y atajos de teclado Una barra secundaria aparece debajo de la barra principal: 🐛 Debug — inicia una sesión de depuración para el archivo activo; queda deshabilitado mientras una ejecución normal está activa. Sincroniza automáticamente los breakpoints del gutter del editor con DebugRunner::breakpoints antes de comenzar. ■ Stop Debug — descarta el canal de comandos, hace una detención controlada, reinicia el panel del depurador y limpia el resaltado de la línea de depuración en el editor. F5 — Continue mientras una sesión está activa. F10 — Step Over mientras una sesión está activa. Adiciones de i18n en los 5 idiomas Nuevas claves: panel_debugger, dbg_continue, dbg_step_over, dbg_pause, dbg_stop, dbg_variables, dbg_filter_hint, dbg_debug. |
Aquí está todo lo que se ha construido hasta ahora:
RustCOBOL Lexer (cobolt-lexer) — Tokenizador para COBOL-85 (ANSI X3.23-1985, mismo que Fujitsu COBOL 3.0). Maneja código fuente tanto de formato fijo como de formato libre, todas las palabras clave estándar, además de extensiones de RustCOBOL (EXEC RUST, verbos de animación PLAY/STOP, INVOKE). RustCOBOL AST (cobolt-ast) — El Árbol de Sintaxis Abstracta. Todos los tipos de nodo derivan Serialize/Deserialize, de modo que el AST puede serializarse para el compilador binario. RustCOBOL Parser (cobolt-parser) — Parser de descenso recursivo que produce un AST Program completo a partir de flujos de tokens. Cubre DATA, PROCEDURE, TRY/CATCH, programas anidados y funciones COBOL-85. RustCOBOL Semantic Analyser (cobolt-semantic) — Valida declaraciones de datos, referencias a variables y existencia de párrafos, y produce diagnósticos con niveles de severidad. RustCOBOL Runtime (cobolt-runtime) — Intérprete tree-walking. Ejecuta el AST directamente. Incluye: Motor de base de datos SQLite (COBOL-OPEN-DB / COBOL-EXEC-SQL / etc.) Cliente HTTP REST (COBOL-HTTP-GET / COBOL-HTTP-POST / etc.) Con el cambio de nombre, el versionado se inicia en 1.0.0 Canales de formularios GUI (eventos ↔ hilo del intérprete) Canales del depurador (breakpoints, step-over, observación de variables) RustCOBOL Standard Library (cobolt-stdlib) — Stubs de biblioteca estándar. PowerRustCOBOL Forms Engine (cobolt-forms) — Modelo de datos de formularios: controles, animaciones y propiedades, con serialización/deserialización XML. El formato de archivo .cfrm. PowerRustCOBOL Code Generator (cobolt-codegen) — Generador de fuente RustCOBOL a partir de formularios. Emite working-storage, programas anidados para manejadores de eventos, stubs SQL, stubs REST y exportación CSV de DataGrid. RustCOBOL Compiler (cobolt-compiler) — Compilador binario embed+bundle. Analiza el proyecto, serializa el AST con bincode+flate2, genera un proyecto Rust autocontenido, llama a cargo build --release y emite un único ejecutable nativo en bin/. rcrun (cobolt-cli) — Runtime de línea de comandos: rcrun run <file.cbl> — ejecuta RustCOBOL desde la terminal rcrun check <file.cbl> — solo hace parsing + verificación semántica rcrun package — comprime el proyecto con launchers rcrun build — compila a un binario nativo PowerRustCOBOL (cobolt-ide) — El RAD principal (egui/eframe), que contiene: Code Editor — editor RustCOBOL con resaltado de sintaxis, gutter de breakpoints, búsqueda y autocompletado Form Designer — constructor visual de formularios drag-and-drop, multi-viewport, tema glass/liquid UI, sistema de animación, z-order, multiselección y herramientas de alineación Form Preview — vista previa interactiva en vivo con imágenes de fondo, animaciones, gráficos y todos los widgets Run Form — ejecuta el RustCOBOL generado en un hilo de intérprete en vivo con canales bidireccionales UI↔COBOL Debugger — breakpoints, step-over/into, panel de observación de variables y resaltado de línea en el editor Project System — proyectos cobolt.toml con fuentes, formularios y assets; File → Package y File → Build Binary Bug Tracker — Help → �� Report a Problem escribe en BUGS.md; escaneo diario programado reporta errores del compilador i18n — 5 idiomas: inglés, español, portugués, japonés y chinocobolt-lexer — Tokenizador para COBOL-85 (ANSI X3.23-1985, mismo que Fujitsu COBOL 3.0). Maneja código fuente tanto de formato fijo como de formato libre, todas las palabras clave estándar, además de extensiones de CobolRust (EXEC RUST, verbos de animación PLAY/STOP, INVOKE). cobolt-ast — El Árbol de Sintaxis Abstracta. Todos los tipos de nodo derivan Serialize/Deserialize, de modo que el AST puede serializarse para el compilador binario. cobolt-parser — Parser de descenso recursivo que produce un AST Program completo a partir de flujos de tokens. Cubre DATA, PROCEDURE, TRY/CATCH, programas anidados y funciones COBOL-85. cobolt-semantic — Analizador semántico. Valida declaraciones de datos, referencias a variables y existencia de párrafos, y produce diagnósticos con niveles de severidad. cobolt-runtime — Intérprete tree-walking. Ejecuta el AST directamente. Incluye: Motor de base de datos SQLite (COBOL-OPEN-DB / COBOL-EXEC-SQL / etc.) Cliente HTTP REST (COBOL-HTTP-GET / COBOL-HTTP-POST / etc.) Canales de formularios GUI (eventos ↔ hilo del intérprete) Canales del depurador (breakpoints, step-over, observación de variables) cobolt-stdlib — Stubs de biblioteca estándar. cobolt-forms — Modelo de datos de formularios: controles, animaciones y propiedades, con serialización/deserialización XML. El formato de archivo .cfrm. cobolt-codegen — Generador de fuente COBOL a partir de formularios. Emite working-storage, programas anidados para manejadores de eventos, stubs SQL, stubs REST y exportación CSV de DataGrid. cobolt-compiler — Compilador binario embed+bundle, Fase 11. Analiza el proyecto, serializa el AST con bincode+flate2, genera un proyecto Rust autocontenido, llama a cargo build --release y emite un único ejecutable nativo en bin/. cobolt-cli — Herramienta de línea de comandos: cobolt run <file.cbl> — ejecuta COBOL desde la terminal cobolt check <file.cbl> — solo hace parsing + verificación semántica cobolt package — comprime el proyecto con launchers cobolt build — compila a un binario nativo cobolt-ide — La aplicación GUI principal (egui/eframe), que contiene: Code Editor — editor COBOL con resaltado de sintaxis, gutter de breakpoints, búsqueda y autocompletado Form Designer — constructor visual de formularios drag-and-drop, multi-viewport — cada formulario en su propia ventana del sistema operativo —, tema glass/liquid UI, sistema de animación, z-order, multiselección y herramientas de alineación Form Preview — vista previa interactiva en vivo del formulario diseñado, con imágenes de fondo, animaciones, gráficos y todos los controles Run Form — ejecuta el COBOL generado por el formulario en un hilo de intérprete en vivo con canales bidireccionales de eventos UI↔COBOL Debugger — breakpoints, step-over/into, panel de observación de variables y resaltado de la línea de depuración en el editor Project System — proyectos cobolt.toml que rastrean fuentes, formularios y assets; File → Package y File → Build Binary Bug Tracker — Help → �� Report a Problem escribe en BUGS.md; escaneo diario programado reporta errores del compilador i18n — 5 idiomas: inglés, español, portugués, japonés y chino |
quiero agradecer la iniciativa de Eslopes para los cobolores que quieren actualizarse.
Solo una duda, el manejador de datos cual seria? sql? isam? vbisam? |
1 Archivos Adjunto(s)
Repositorio creado en GitHub.
Por el momento, el repositorio es privado, con acceso permitido únicamente a los sponsors del proyecto. Cuando alcancemos una versión estable, lo liberaremos para los demás. Mantendremos a todos informados sobre el progreso aquí en este foro. Actualmente, PowerRustCOBOL soporta SQLite, pero añadiremos soporte para MySQL, PostgreSQL, Oracle y Microsoft SQL Server, además de ISAM, con formato seleccionable — RM/COBOL-85, Fujitsu COBOL-85 y otros en el futuro — de acuerdo con nuestro roadmap. Necesitamos comprar créditos para usar Claude Code. Sin ellos, el desarrollo se prolongará durante mucho tiempo, ya que la cuenta actual tiene limitaciones. |
Cita:
|
Parabéns pela iniciativa, sem duvida que é algo muito interessante e que pode dar um novo alento.
Estou interessado em fazer doação dos 10 dolares. Como o fazer ? |
Chicos, acabo de enterarme de que PayPal ha cerrado la cuenta del foro, sin razón aparente... :(
No sé qué opciones conocéis para poder transferir sin que sea complicado. @Eslopes, tú qué opciones conoces y prefieres ? |
Donaciones de tiempo y dinero
Estimados,
He creado un repositorio en GitHub y he activado la función de donaciones. Para acceder al repositorio — y tener acceso al código fuente — es necesario que ustedes: Donaciones de dinero 1. Creen una cuenta en GitHub. Es gratuita. 2. Me informen el username creado, para que pueda liberar el acceso al repositorio (email para [email protected]). 3. En la página del repositorio, hagan clic en el botón Sponsor y realicen la donación. Donaciones de tempo Necesitamos es feedback sobre el producto: qué no funciona, qué no funciona como debería, qué debería existir y todavía no fue implementado. Cualquier problema encontrado debe ser publicado en el foro. El propio agente que estoy usando hará la lectura, confirmará los problemas y generará una lista de lo que necesita ser corregido, para que yo pueda revisarlo y aprobarlo. Las sugerencias serán analizadas en cuanto a su viabilidad y puestas a votación todas las semanas. Todo dependerá de cuánto logremos recaudar para acelerar el desarrollo. Usando la cuenta básica que tengo, esto puede llevar un año. Con la ayuda de todos, podremos reducir este tiempo a cerca de 1 a 3 meses (possivelmente). Haremos campañas constantes de recaudación, con Super Chat en YouTube los sábados, para hablar sobre el proyecto, responder dudas, hacer demostraciones, etc. Las donaciones también podrán hacerse por YouTube. El proyecto está en marcha, pero dado que esta es una actividad sin fines de lucro de mi parte, necesito concentrarme durante el horario laboral en mi trabajo principal. Por lo tanto, no esperen actividad de mi parte durante el horario comercial, de lunes a viernes. Dicho esto, ya se ha hecho mucho, y muchas cosas están en desarrollo. Así que pronto tendremos una versión alpha — luego beta, release candidate y, finalmente, una versión de producción. No hay garantías de que logremos implementar un proyecto de este tamaño con los servicios actuales de inteligencia artificial. Siempre existe la posibilidad de encontrar un bloqueo importante, pero hasta ahora todo está funcionando perfectamente. Una de las cosas que ya fue implementada es el soporte al comportamiento de los archivos indexados de Fujitsu COBOL85, pero con soporte de 64 bits, lo que significa que un archivo indexado podrá tener tamaños de petabytes. Otra cosa que se está implementando es el journaling para archivos indexados, lo que permitirá operaciones de commit/rollback y aumentará la seguridad del archivo. Hay muchas otras cosas que quiero implementar, pero por ahora estoy manteniendo un roadmap factible. ¡Vamos a hacer historia juntos! Me siento como un niño en una tienda de dulces. Todos sabemos que el acceso a disco siempre es el cuello de botella de cualquier aplicación. El agent implementó un sistema de archivos indexados que funciona básicamente en memoria, descargando el contenido al disco en el COMMIT o en el CLOSE. Obviamente, esto es peligroso por el riesgo de pérdida de datos, pero es aceptable en procesos internos donde hacemos una indexación temporal de datos. Trabajar en memoria es prácticamente instantáneo. Añadí sintaxis para trabajar con almacenamiento directo en disco o en memoria. Bueno, ¿por qué detenerse aquí? También añadí una cláusula de compresión de datos usando un algoritmo RLE, que reduce el tamaño del registro en más de un 50%. Es decir, se duplica la velocidad de lectura de los registros sin ningún esfuerzo. SELECT file-name ASSIGN TO external-file-name ORGANIZATION IS INDEXED [STORAGE IS { MEMORY | DISK } [WITH COMPRESSION]] ACCESS MODE IS { SEQUENTIAL | RANDOM | DYNAMIC } RECORD KEY IS data-name [ALTERNATE RECORD KEY IS data-name [WITH DUPLICATES]] [FILE STATUS IS data-name]. El valor predeterminado es disco sin compresión, por lo que esta opción solo se aplica a archivos nuevos. Así, los datos almacenados a largo plazo residen en el disco desde el momento del WRITE/REWRITE —y se eliminan inmediatamente del disco después de un DELETE—, pero con la opción de compresión se tarda menos en leer o escribir, y el tiempo de compresión/descompresión es despreciable. Todos los recursos están siendo probados exhaustivamente, y el código de pruebas del compilador queda en el propio repositorio para que pueda ser analizado o ejecutado en cualquier momento. El enlace al repositorio será enviado por correo electrónico después de que informen su username de GitHub. |
Not bad, not bad at all
FILE I/O TEST SUITE =================== All files are created under /tmp Existing files with the same names may be replaced. SEQUENTIAL FILE TESTS File: /tmp/seq-test.dat PASS S001 OPEN OUTPUT SEQUENTIAL PASS S002 WRITE FIRST SEQUENTIAL RECORD PASS S003 WRITE SECOND SEQUENTIAL RECORD PASS S004 OPEN INPUT SEQUENTIAL PASS S005 READ FIRST SEQUENTIAL RECORD PASS S006 READ SECOND SEQUENTIAL RECORD PASS S007 SEQUENTIAL AT END LINE SEQUENTIAL FILE TESTS File: /tmp/lineseq-test.txt PASS L001 OPEN OUTPUT LINE SEQUENTIAL PASS L002 WRITE FIRST LINE PASS L003 WRITE MIXED CASE LINE PASS L004 WRITE LOWERCASE LINE PASS L005 OPEN INPUT LINE SEQUENTIAL PASS L006 READ FIRST LINE PASS L007 READ MIXED CASE LINE PASS L008 READ LOWERCASE LINE PASS L009 LINE SEQUENTIAL AT END INDEXED FILE TESTS File: /tmp/idx-main.dat PASS I001 OPEN OUTPUT INDEXED MAIN PASS I002 WRITE UPPERCASE PRIMARY KEY PASS I003 WRITE LOWERCASE PRIMARY KEY PASS I004 WRITE MIXED CASE PRIMARY KEY PASS I005 WRITE ALPHABETIC-ONLY PRIMARY KEY CONTENT PASS I006 DUPLICATE PRIMARY KEY RETURNS 22 PASS I007 DUPLICATE ALTERNATE KEY WITHOUT DUPLICATES PASS I008 OPEN I-O INDEXED MAIN PASS I009 RANDOM READ BY LOWERCASE PRIMARY KEY PASS I010 RANDOM READ BY UNIQUE LOWER ALTERNATE KEY PASS I011 START/READ DUPLICATE UPPER ALTERNATE KEY PASS I012 START/READ DUPLICATE MIXED ALTERNATE KEY PASS I013 START GE PRIMARY KEY PASS I014 START INVALID KEY RETURNS 23 PASS I015 REWRITE INDEXED RECORD PASS I016 READ REWRITTEN INDEXED RECORD PASS I017 DELETE CURRENT INDEXED RECORD PASS I018 READ DELETED RECORD RETURNS 23 INDEXED NUMERIC KEY TESTS File: /tmp/idx-numeric.dat PASS N001 OPEN OUTPUT NUMERIC KEY INDEXED FILE PASS N002 WRITE NUMERIC KEY 00000001 PASS N003 WRITE NUMERIC KEY 00001000 PASS N004 RANDOM READ NUMERIC DISPLAY KEY INDEXED ALPHABETIC KEY TESTS File: /tmp/idx-alpha.dat PASS A001 OPEN OUTPUT ALPHA KEY INDEXED FILE PASS A002 WRITE UPPER ALPHA KEY PASS A003 WRITE LOWER ALPHA KEY CONTENT PASS A004 WRITE MIXED ALPHA KEY CONTENT PASS A005 RANDOM READ MIXED ALPHA KEY INDEXED PERFORMANCE PROFILE File kept on disk after test. File path: /tmp/idx-perf-uuid-1m.dat Record count target: 1,000,000 Primary key size: 40 bytes Record size: 1024 bytes PASS P001 OPEN OUTPUT PERFORMANCE INDEXED FILE PASS P002 PERFORMANCE FILE WRITE LOOP COMPLETED INDEXED WRITE PERFORMANCE STATISTICS Path : /tmp/idx-perf-uuid-1m.dat Start time HHMMSSHS : 05372400 End time HHMMSSHS : 05374400 Records attempted : 1,000,000 Elapsed seconds : 20.00 Records per second : 50,000 Approx data MB : 976 Final file status : 00 PASS P003 OPEN INPUT PERFORMANCE INDEXED FILE PASS P004 PERFORMANCE FILE READ LOOP COMPLETED INDEXED READ PERFORMANCE STATISTICS (READ INVALID KEY) Path : /tmp/idx-perf-uuid-1m.dat Start time HHMMSSHS : 05374400 End time HHMMSSHS : 05380100 Records attempted : 1,000,000 Records found : 1,000,000 Elapsed seconds : 17.00 Records per second : 58,823 Final file status : 00 PASS P005 OPEN INPUT PERFORMANCE INDEXED FILE FOR SCAN PASS P006 PERFORMANCE FILE SEQUENTIAL SCAN COMPLETED INDEXED SCAN PERFORMANCE STATISTICS (READ NEXT) Path : /tmp/idx-perf-uuid-1m.dat Start time HHMMSSHS : 05380100 End time HHMMSSHS : 05380600 Records scanned : 1,000,000 Records found : 1,000,000 Elapsed seconds : 5.00 Records per second : 200,000 Final file status : 00 The indexed performance file was intentionally kept. =================== TESTS RUN : 00049 TESTS PASSED : 00049 TESTS FAILED : 00000 RESULT : PASS |
¡Estoy asombrado por el progreso casi increíble de este proyecto!
Qué tipo de archivos indexados se utilizan? C-ISAM, D-ISAM...son compatibles con Fujitsu? De qué proveedor? ¿Gratuita o de pago? El acceso SQL previsto es nativo o mediante ODBC? Gracias, buen trabajo, José |
El archivo indexado de RustCOBOL no es compatible con Fujitsu en términos de estructura de archivo, pero implementa el 99 % de la especificación COBOL-85 utilizada por Fujitsu COBOL85, lo que facilita la conversión de datos de un formato a otro prácticamente sin impactos en el código.
RustCOBOL y TODOS sus componentes son OPEN-SOURCE y GRATUITOS. Nada de licencias pagas, aunque en el futuro podamos ofrecer soporte pago. Nuevamente: el compilador, el RAD y las herramientas son 100 % gratuitos. ¡100 %! En este momento estamos intentando, tanto como sea posible, evitar dependencias externas. Todavía no tenemos, por ejemplo, soporte para videos H.264 por el simple hecho de que esto requiere componentes externos, aunque sean gratuitos. Queremos una implementación limpia, 100 % Rust. El widget de acceso a base de datos soporta SQLite, PostgreSQL y MySQL a través de bibliotecas Rust. Sobre el sistema de archivos indexados de RustCOBOL (ISAM) 1. Arquitectura Un único trait IndexedStore (crates/cobolt-runtime/src/indexed.rs) define la interfaz que utiliza el intérprete. Hay dos backends detrás de un Box<dyn IndexedStore>: [TABLE]Backend|STORAGE IS|Archivo|Característica[/TH][/TR] IndexedFile (memoria)|MEMORY|indexed.rs|todo en RAM; se guarda en CLOSE DiskIndexedFile (disco)|DISK (por defecto)|indexed_disk.rs|archivo paginado persistente, leído bajo demanda [/TABLE] Sin dependencias externas — motor ISAM propio. “Sabor” de engine: Código:
--indexed-engine {rust|rm-cobol85|fujitsu}Código:
COBOL_INDEXED_ENGINELos verbos de archivo son despachados por la ORGANIZATION del SELECT. 2. Engine de memoria (indexed.rs) Código:
records: BTreeMap<clave-primaria, registro> // KSDS ordenado3. Engine de disco (indexed_disk.rs) — formato PRCIDXD1 Páginas fijas de 4 KiB, con free-list. Las páginas liberadas son reutilizadas. Los punteros y contadores son u64. B+tree por clave — primaria + alternativas: hojas/internas byte-packed, split en la inserción y hojas doblemente encadenadas para barrido ordenado. Directorio de RecordId: RecordId estable → ubicación física. Un REWRITE que mueve el registro actualiza solo el directorio. Slotted data pages: varios registros por página + cadena de overflow para registros mayores que una página. WITH COMPRESSION: RLE estilo PackBits (compress.rs), rápido, y nunca crece más de 1 byte. Undo log en ejecución — nuevo en v1.8.0: soporta ROLLBACK real. Antes era no-op. 4. Transacciones COMMIT / ROLLBACK (v1.8.0) Semántica — se aplican a todos los archivos INDEXED abiertos: [TABLE]Verbo|Efecto[/TH][/TR] OPEN|inicia una transacción COMMIT|hace durable todo desde el último COMMIT/OPEN e inicia una nueva transacción ROLLBACK|deshace todo WRITE/REWRITE/DELETE desde el último COMMIT/OPEN CLOSE|persiste los cambios mediante commit implícito [/TABLE] Implementación: el engine acumula un undo log con operaciones inversas:
ROLLBACK reaplica los inversos en orden reverso, con guard tx_replay para no registrar nuevamente en el log, y vuelve a persistir. COMMIT descarta el log y ejecuta sync_all. COMMIT y ROLLBACK son tokens reservados. No son absorbidos por un DISPLAY anterior. Atención: es rollback a nivel de programa, dentro de la ejecución. La recuperación post-crash mediante WAL durable sigue siendo trabajo futuro. 5. Recursos implementados Claves: RECORD KEY única + N ALTERNATE RECORD KEY [WITH DUPLICATES]. Modos de acceso: Código:
ACCESS MODE SEQUENTIALCódigo:
OPEN {INPUT|OUTPUT|I-O|EXTEND} [SHARING WITH …][WITH LOCK]Código:
00, 02, 10, 22, 23, 24, 35, 46, 47/48/49, 99, …6. Ejemplos de uso — ejecutados ahora (1) CRUD con clave primaria + alternativa, DISK WITH COMPRESSION Flujo: Código:
OPEN OUTPUT/I-OCódigo:
RANDOM 0002: BRUNOOtro proceso solo lee el archivo /tmp/clientes.idx de la ejecución anterior: Código:
Reabierto (otra ejecución). Registros persistidos:Graba GAMMA, hace COMMIT. Después graba DELTA, altera ALPHA, borra BETA y hace ROLLBACK: Código:
OPEN I-O FCódigo:
Después del ROLLBACK, barrido:[TABLE]Suite (Rust)|Resultado test_transactions (COMMIT/ROLLBACK — disco y memoria)|2 passed test_indexed (engine ISAM)|2 passed test_file_locking (OPEN SHARING/LOCK, READ WITH [NO] LOCK, UNLOCK, CANCEL)|4 passed test_fileio_storage (6 variantes: baseline + memory/disk × compression)|7 passed [/TABLE] El acceso SQL previsto es nativo o mediante ODBC? (Drivers nativos de Rust para SQLite, MySQL y PostgreSQL) Cita:
Conviértete en sponsor para descargar el código, seguir de cerca el progreso y contribuir con las pruebas. ¡Saludos! |
OK, Ja sei que tambem falam em Portugues!!
Nao estou a conseguir fazer doaçao. Esta operacional?! GitHub - CloudLandBeta/PowerRustCOBOL-funding: Public repository for gaining access to the private PowerRustCOBOL repository containing the source code by becoming a sponsor. · GitHub Boa continuaçao. Cita:
|
Grato por sua resposta. Estou aguardando a aprovação do GitHub dos dados fiscais que fui obrigado a fornecer. Deve ser liberado em breve. Colocarei um aviso no fórum.
Aquí está el esquema conceptual del motor de índice en disco implementado (DiskIndexedFile, contenedor PRCIDXD1). Este es el formato persistente; el motor en memoria es un subconjunto simplificado del mismo modelo. 1. El archivo = un array de páginas fijas de 4 KiB byte 0 end of file ┌────────┬────────┬────────┬────────┬────────┬──── ────┬───── ... ─────┐ │ Page 0 │ Page 1 │ Page 2 │ Page 3 │ Page 4 │ Page 5 │ ... │ │ HEADER │ B+tree │ B+tree │ DATA │ DATA │ DIR │ │ └────────┴────────┴────────┴────────┴────────┴──── ────┴───────────────┘ Cada página tiene exactamente PAGE_SIZE = 4096 bytes; page id = desplazamiento en bytes / 4096 Cada página después de la página 0 se identifica por su primer byte (etiqueta de tipo): | Tag | Page type | Contenido | |-----|-------------|------------------------------------------------| | 1 | PT_INTERNAL | Nodo interno de B+tree | | 2 | PT_LEAF | Nodo hoja de B+tree (doubly linked) | | 3 | PT_DATA | Página con slots que contiene varios registros | | 4 | PT_OVERFLOW | Continuación para registros demasiado grandes | | 5 | PT_DIR | Un fragmento del directorio de RecordId | Las páginas pueden liberarse y reutilizarse mediante una free list, por lo que el orden físico en disco no corresponde al orden lógico. 2. Página 0 — el encabezado (se escribe una sola vez, es el único esquema del archivo) PRCIDXD1 version page_size rec_fmt compressing record_len (8 bytes) (u16) (u32) (u8=1) (u8 0/1) (u32) ────────────────────────────────────────────────── ──────────── next_page_id free_list_head record_count data_tail (cada u64) primary_root dir_head directory_len (cada u64) ────────────────────────────────────────────────── ──────────── alt_root_count (u16) → [ alt_root : u64 ] × N (una raíz B+tree por clave alternativa) ────────────────────────────────────────────────── ──────────── KEY SCHEMA: key_count (u16) → para cada clave: duplicates_allowed (u8) part_count (u16) → [ offset:u32, length:u32 ] × partes (claves compuestas) Nota: No hay nombres de campos ni metadatos por registro. El esquema solo define la geometría de las claves (rangos de bytes). 3. Ruta de acceso (cómo se resuelve un READ) COBOL key value (bytes) │ ▼ ┌──────────────┐ primary_root / alt_roots[k] │ B+tree (uno │ por clave. Las páginas internas enrutan; │ por clave) │ las hojas contienen (key_bytes → RecordId) └──────┬───────┘ y están doubly linked para READ NEXT / PREVIOUS. │ RecordId (un entero estable) ▼ ┌──────────────┐ directory[RecordId] = RecLoc │ Directorio │ { kind, page, slot, len } │ de RecordId │ kind: 0=free/tombstone 1=inline 2=overflow └──────┬───────┘ │ (page, slot) ▼ ┌──────────────┐ slotted DATA page → slot dir → (offset,len) │ DATA page │ → imagen raw del registro (opcionalmente comprimida) └──────┬───────┘ ▼ los bytes del registro de ancho fijo → RecordLayout.distribute() los distribuye en los subcampos del FD en memoria. Todos los índices (primario + alternos) apuntan al mismo RecordId, por lo que existe exactamente una copia de cada registro. 4. Una página PT_DATA vista en detalle ┌─ byte 0 ─┬─ 1..3 ─┬─ 3..5 ──┬─ slot directory ─────┬─ ... free ... ─┬─ record data ─┐ │ type=3 │ slot_ │ free_ │ (off:u16,len:u16) ×N │ │ packed │ │ │ count │ top │ grows → │ │ ← grows │ └──────────┴────────┴─────────┴─────────────────── ───┴───────────────┴───────────────┘ El directorio de slots crece desde el frente, los registros desde el final. Los registros más grandes que una página se desbordan en una cadena PT_OVERFLOW. 5. Imagen del registro (posicional, sin nombres) Ejemplo: 01 CUST. 05 ID PIC 9(5). 05 NAME PIC X(10). 05 CITY PIC X(8).: offset: 0 5 15 23 ┌────────┬────────────────────┬────────────── ─┐ payload: │ 00001 │ John Doe │ Sao Paulo │ ← 23 bytes, fixed └────────┴────────────────────┴────────────── ─┘ ID(5) NAME(10) CITY(8) materialize() empaqueta los subcampos en este buffer; distribute() hace lo inverso. Con compresión, se aplica PackBits-RLE. 6. Estructuras transversales * Free list — free_list_head encadena las páginas liberadas para reutilizar espacio. * Directorio de RecordId — reside en RAM mientras el archivo está abierto, se persiste en páginas PT_DIR. * Transacciones — undo log en RAM (inversas de Insert/Update/Delete). ROLLBACK las aplica; COMMIT las descarta y hace flush. * Validación estricta en OPEN — compara el esquema de claves almacenado con el del programa; mismatch → file status 39. En una oración: un archivo paginado compuesto por un header + N B+trees (uno por clave) → directorio de RecordId → páginas de datos con slots de registros de ancho fijo posicionales, con free list, cadenas de overflow, compresión RLE opcional y undo log para transacciones. |
Estimados,
Les comparto el enlace a la página de financiación. Para contribuir, hagan clic en el botón “Sponsor”. Al realizar una donación mensual, tendrán acceso al repositorio privado con el código fuente: GitHub - CloudLandBeta/PowerRustCOBOL-funding: Public repository for gaining access to the private PowerRustCOBOL repository containing the source code by becoming a sponsor. · GitHub Conviértanse en patrocinadores hoy mismo y ayuden a construir la nueva generación de entornos gráficos para COBOL, con soporte para Generative AI, REST APIs, servicios en la nube, integración con Rust y mucho más. Con su apoyo, será posible acelerar el desarrollo, mejorar la estabilidad, crear ejemplos, ampliar la documentación y transformar PowerRustCOBOL en una plataforma moderna, abierta y útil para la comunidad COBOL. ¡Saludos! |
3 Archivos Adjunto(s)
Ahora la IDE cuenta con una mejor estructura para los proyectos. La buena y vieja conocida vista en árbol de proyectos está de vuelta, así como la capacidad de modificar rápidamente las propiedades de los objetos de un formulario sin abrir el RAD.
¡Saludos! |
Cita:
You were removed from the CloudLandBeta organization because you don’t meet its two-factor authentication requirements. Review your two-factor authentication settings. |
Review your two-factor authentication settings
Si, es necesario habilitar autenticación usando um dispositivo que gere um token (pode ser o app do google authenticator no celular ou o app do próprio GitHub)
Cita:
Muchas personas están dispuestas a financiar el proyecto, pero GitHub tarda algunas semanas en aprobar la documentación requerida. Voy a poner el repositorio del código de PowerRustCOBOL como público, de modo que, por ahora, cualquiera podrá descargar el código fuente sin donar nada. El código aún no está completamente funcional, excepto por el compilador. Muchos widgets todavía tienen propiedades o métodos que no funcionan. Estoy corrigiéndolos uno por uno, pero llevará algún tiempo. Por eso, no tiene sentido exigir en este momento donadores regulares para algo que TODAVÍA no tiene mucha utilidad práctica. Al liberar el código para descarga, todos podrán contribuir con sugerencias. Recordando que la solución en sí es gratuita y seguirá siéndolo debido a la licencia Apache 2.0. Aunque el compilador, el entorno de desarrollo gráfico y el runtime sean gratuitos y open-source, la integración con la nube y con modelos de Generative AI para generación de código o análisis de datos podrán tener costos. Aun así, nada impedirá que alguien cree su propia infraestructura en la nube para complementar la IDE. Repito: la IDE, el compilador y el runtime no dependen de servicios actuales ni futuros para ejecutarse. Sin embargo, ciertas funciones que consumen servicios externos, ya sea en Google Cloud o en AWS, podrán generar costos por el uso de dichos servicios. El propio Anthropic Claude Code, usado intensamente en el desarrollo de PowerRustCOBOL, es pago y tiene un costo elevado. Ya existe una Guía del Desarrollador de PowerRustCOBOL. Todavía necesita algunas imágenes y el contenido aún está en proceso de redacción, pero ya permite tener una idea clara de lo que es el proyecto. Accede aquí al repositorio público de PowerRustCOBOL: GitHub - CloudLandBeta/PowerRustCOBOL: Modern IDE for development of COBOL applications connected to the Cloud, Agentic AI, and rich UI. 100% Free · GitHub Una cosa que siempre me incomodó en PowerCOBOL 3, y que ahora pude —y de hecho corregí—, fue el soporte a inferencia de tipos. Siguen algunos ejemplos: PowerCOBOL: Código COBOL:
PowerRustCOBOL: Código COBOL:
|
Una versión en español del Developer’s Guide (Guía del Desarrollador) está disponible en el GitHub de PowerRustCOBOL.
|
Cita:
P.D. creo que @Nitzer va a fliapr cuando vea la que se está montando :D :D :D |
1 Archivos Adjunto(s)
IDE casi terminada; el RAD, no tanto.
Cada día, una imagen diferente. Cada 6 segundos, una cita para inspirar tu día. |
tal vez es una obviedad pero... se puede publicar o mostrar como ejemplo el github público de PowerRustcobol y esta hilo en otros lugares sobre LLM y claude code?
|
Este foro es público, lo que significa que el contenido que publicamos aquí puede compartirse o utilizarse sin necesidad de permiso previo. El único detalle que llama la atención aquí es que el repositorio de PowerRustCOBOL pasará a ser privado tan pronto como GitHub apruebe la documentación que permite aceptar patrocinadores. Apuntar a un repositorio que eventualmente será puesto como privado —y que después volverá a ser público solo dentro de algunos meses— dará como resultado un error 404, dando la impresión de que el proyecto murió para quien intente acceder a tu enlace. En fin, no tengo objeciones si quieres publicar este hilo en otros lugares, pero quería dejar esta observación.
Cita:
|
Hola,
Vamos a necesitar un nuevo foro: PowerRustWebCOBOL. Además de ofrecer el soporte tradicional para macOS, Linux y Windows, PowerRustCOBOL recibirá un módulo para desarrollar aplicaciones gráficas para el navegador web usando WebAssembly. La idea es mantener el mismo look and feel, el mismo modelo visual y de eventos, y los mismos recursos del entorno desktop —con algunos recursos adicionales—, pero permitiendo que la aplicación se ejecute en el navegador de forma nativa mientras accede a datos de manera remota. Pronto publicaremos un ejemplo. Hasta donde sé, ningún otro compilador COBOL ofrece una experiencia RAD moderna, inspirada en PowerCOBOL, capaz de generar aplicaciones gráficas para el navegador usando WebAssembly y manteniendo el mismo modelo visual y de eventos del entorno desktop. Más información: |
Existe algo que devo estar a fazer mal, mas não consigo fazer a doação.
Podem ajudar ? |
Cita:
José. |
Não depende de mim. O Github ainda não aprovou o sponsorship, apesar de ter passado todas as informações que solicitaram.
acho que vou usar o gofundme para isto.... Cita:
|
| La franja horaria es GMT +2. Ahora son las 09:49. |
Powered by: vBulletin, Versión 3.8.7
Derechos de Autor ©2000 - 2026, Jelsoft Enterprises Ltd.