/hispatec/ - Tecnologia hispana

Refugio del /t/ de hispa

Página principal Catálogo Archivar Bajar Actualizar
Opciones
Título
Mensaje

Máximo de caracteres: 12000

archivos

Tamaño máximo de archivo: 32.00 MB

Tamaño máximo de archivo en total: 50.00 MB

Numero máximo de archivos: 5

Supported file types: GIF, JPG, PNG, WebM, OGG, and more

Correo
Clave

(usado para eliminar archivos y mensajes)

Misc

Recuerda leer las reglas

The backup domains are located at 8chan.se and 8chan.cc. TOR access can be found here, or you can access the TOR portal from the clearnet at Redchannit 3.0.

Pantalla Fantasma
Soy Un Vampiro, El Pedazo Te Miro


8chan.moe is a hobby project with no affiliation whatsoever to the administration of any other "8chan" site, past or present.

Otros tablones: /hisparefugio /ac /arte /av /hisrol /vt /arepa /esp /col /cc /mex /pe /hispol Contacto: drzmx@cock.li SI TU HILO ERA UNA CONSULTA SIMPLE, Y NO LO VES, SE HA FUSIONADO CON EL HILO GENERAL DE PREGUNTAS

Tengo acceso a Github Copilot hasta el 22 de agosto y te lo muestro Anónimo 16/08/2022 (Mar) 14:45:45 200
Para los que se pregunten ¿que putas es Github Copilot?, se trata de un plugin de autocompletado que genera código con solo describir lo que quieres en un comentario. En https://www.youtube.com/watch?v=vN7tk0ufLTM se pueden hacer una mejor idea de como funciona. Pero primero, un poco de contexto antes de seguir: >Ser yo entre fines de abril y comienzos de mayo >Ver hilo en el viejo /t/ sobre un negro presumiendo que gana una millonada usando Github Copilot >Probablemente ese negro ser mitomano, pero aun así comenzar a tener mas curiosidad sobre el tema luego de ver el vídeo que dejar mas arriba >Solicitar prueba gratuita en https://github.com/features/copilot/ y olvidarme del asunto >ffw 31 de mayo >Volver a encontrar el hilo sobre Github Copilot >Revisar mi email y descubrir que la semana anterior me habían aceptado para la prueba gratuita >Unas horas antes del cierre de Hispa comentar que me habían dado acceso y que me hubiera gustado hacer algunas mierdas que tengo en mente junto con cualquier pendejada que sugirieran los demás Debido a varias cuestiones que no vienen al caso, no pude comenzar a probarlo antes y recién ahora me he dado el tiempo para configurar, instalar y activar lo que me hacia falta. Tal como dije antes, en estos días estaré probando a generar cosas por mi cuenta (algunas las pienso compartir aquí) y de paso pueden sugerir otras para ver que me genera el Copilot. También pueden aprovechar para preguntar cualquier cosa al respecto, comentar experiencias que hayan tenido con este tipo de plugins o sugerir otras alternativas. >inb4 muh tablón lolmorido Se que si lo hago en >>>/hispachan/ esto tendría mayor visibilidad, pero no me interesa preocuparme de que el hilo quede sepultado por todo el shitpost que abunda en el tablón. Ademas, al tener el hilo aquí puedo retomarlo en caso de que después quiera solicitar la prueba gratuita desde otra cuenta que tengo (aunque probablemente se demore un mes o mas hasta que me den el acceso), o si otro negro lo quiere aprovechar para postear sus códigos generados con IA. Para no dejarlos con las ansias, en la segunda imagen pueden ver lo que se obtiene al ejecutar esto desde Python: import turtle t = turtle.Turtle() t.speed(0) t.hideturtle() t.penup() t.goto(-100,0) t.pendown() t.circle(100) t.penup() t.goto(0,0) t.pendown() t.circle(100) t.penup() t.goto(100,0) t.pendown() t.circle(100) t.penup() t.goto(0,0) t.pendown() t.circle(100) t.penup() t.goto(0,0) t.pendown() Es lo que genera al pedirle que dibuje el logo del chan (una ñ dentro de un circulo). Otra cosa que pedí fue esta cuenta atrás en Javascript: /* Cuenta atras con formatos de tiempo */ var cuentaAtras = { segundos: 0, minutos: 0, horas: 0,
[Expand Post] dias: 0, meses: 0, anyos: 0, iniciar: function(segundos, minutos, horas, dias, meses, anyos) { this.segundos = segundos; this.minutos = minutos; this.horas = horas; this.dias = dias; this.meses = meses; this.anyos = anyos; this.actualizar(); this.mostrar(); this.contador(); }, actualizar: function() { this.segundos = this.segundos - 1; if (this.segundos < 0) { this.segundos = 59; this.minutos = this.minutos - 1; } if (this.minutos < 0) { this.minutos = 59; this.horas = this.horas - 1; } if (this.horas < 0) { this.horas = 23; this.dias = this.dias - 1; } if (this.dias < 0) { this.dias = 30; this.meses = this.meses - 1; } if (this.meses < 0) { this.meses = 11; this.anyos = this.anyos - 1; } }, mostrar: function() { var cuentaAtras = document.getElementById('cuentaAtras'); cuentaAtras.innerHTML = this.anyos + ' años, ' + this.meses + ' meses, ' + this.dias + ' días, ' + this.horas + ' horas, ' + this.minutos + ' minutos y ' + this.segundos + ' segundos'; } } cuentaAtras.iniciar(0, 0, 0, 0, 0, 0); function contador() { cuentaAtras.actualizar(); cuentaAtras.mostrar(); setTimeout('contador()', 1000); } Tiene buena pinta pero aun no lo he probado y es posible que tire algún error.
Dos cosas que acabo de descubrir es que no funciona con ensamblador (o al menos con archivos .asm) ya que solo devuelve código Javascript, HTML o ambos. La otra es que si le pides "el sentido de la vida" devuelve cualquier cosa o directamente nada dependiendo del lenguaje.
Crea un chan
>>203 Kek, esto. Por lo menos solo una página en HTML, a ver que sale.
>>203 >>204 Ahí tienen: // Un imageboard engine written in PHP // Copyright (C) 2015 Jacob Alexander // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // ----- Includes ----- require_once 'config.php'; require_once 'functions.php'; // ----- Setup ----- // Connect to the database $db = new mysqli($config['db']['host'], $config['db']['user'], $config['db']['pass'], $config['db']['name']); if ( $db->connect_error ) { die('Connect Error (' . $db->connect_errno . ') ' . $db->connect_error); } // Check if the board is enabled if ( !$config['board']['enabled'] ) { die('Board is disabled'); } // Check if the board is locked if ( $config['board']['locked'] ) { die('Board is locked'); } // Check if the board is archived if ( $config['board']['archived'] ) {
[Expand Post] die('Board is archived'); } // Check if the board is in maintenance mode if ( $config['board']['maintenance'] ) { die('Board is in maintenance mode'); } // Check if the board is in development mode if ( $config['board']['development'] ) { die('Board is in development mode'); } // Check if the board is in testing mode if ( $config['board']['testing'] ) { die('Board is in testing mode'); } // Check if the board is in beta mode if ( $config['board']['beta'] ) { die('Board is in beta mode'); } // Check if the board is in alpha mode if ( $config['board']['alpha'] ) { die('Board is in alpha mode'); } // Check if the board is in private mode if ( $config['board']['private'] ) { die('Board is in private mode'); } Luego de eso el autocompletado parece entrar en un bucle ya que solo sugiere el ultimo if una y otra vez. Y esto es lo que genera cuando le pido lo mismo en HTML: <!-- A imageboard. --> <html> <head> <title>Test</title> <link rel="stylesheet" type="text/css" href="style.css"> </head> <body> <div class="header"> <h1>Test</h1> </div> <div class="navbar"> <ul> <li><a href="index.php">Home</a></li> <li><a href="post.php">Post</a></li> <li><a href="about.php">About</a></li> <li><a href="contact.php">Contact</a></li> </ul> </div> <div class="content"> <h2>Test</h2> <p>This is a test.</p> </div> <div class="footer"> <p>&copy; Test</p> </div> </body> </html> Como no me dijeron si querían el engine en algún lenguaje lo hice en PHP (olvide aclarar eso cuando hice el hilo, por lo que entiendo soporta los lenguajes mas populares excepto ensamblador). Algo que también note es que Copilot parece ofrecer mejores resultados mientras mas específicos sean los comentarios.
(17.05 KB 840x80 Saludo.png)

Por si alguien se lo estaba preguntando, esto también permite hacer programas con interfaz gráfica tal como pueden ver en la imagen adjunta. Se trata de un simple "hola mundo" hecho con Qt y C++. A continuación les dejo el código correspondiente: // Programa en Qt que muestra una ventana con una etiqueta que dice "Hola a todos los /t/ecnonegros post Hispagedon" con tipo de fuente Piximisa y tamaño de letra 30 // Autor: // Fecha: // Version: 1.0 // Compilador: gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3 // Descripción: // ***************************************************************************** #include <QApplication> #include <QWidget> #include <QLabel> #include <QFont> int main(int argc, char *argv[]) { QApplication a(argc, argv); QWidget w; QLabel l("Hola a todos los tecnonegros post Hispagedon", &w); l.setFont(QFont("Piximisa", 30)); w.show(); return a.exec(); } Tuve que corregir los includes a mano ya que olvide indicar la versión de Qt, pero lo demás lo genero Copilot. Si alguien lo quiere compilar pueden seguir el procedimiento de https://vitux.com/compiling-your-first-qt-program-in-ubuntu/
(261.30 KB 1261x1000 158995757125.jpg)

>>200 Prueba a hacer un proyecto completo, como un Sudoku o un Tetris, a ver que sale.
>>207 >Ubuntu/Linaro >Linaro Kek
Haz un ransonguar
>>200 Haz un programa que haga catálogos de películas, libros, música, porno de los archivos digitales y con sus metadatos, con un solo clic.
>>208 >hacer un proyecto completo Pues falla bastante en ese aspecto ya que al pedirle un juego de tetris en Python a lo mucho solo genera los imports, algunas variables y poco mas. Después parece que no sabe muy bien que hacer (y yo tampoco ya que programar juegos nunca me llamo mucho). Aun así pude hacer esto en Javascript: /* Generador de sudoku que devuelve una tabla con el sudoku generado */ function generarSudoku() { var tabla = []; var fila = []; for (var i = 0; i < 9; i++) { fila = []; for (var j = 0; j < 9; j++) { fila.push(0); } tabla.push(fila); } var numero = 1; var posicion = 0; var fila = 0; var columna = 0; var cuadrante = 0; var filaCuadrante = 0; var columnaCuadrante = 0; while (numero <= 9) { posicion = Math.floor(Math.random() * 81); fila = Math.floor(posicion / 9); columna = posicion % 9; cuadrante = Math.floor(fila / 3) * 3 + Math.floor(columna / 3); filaCuadrante = Math.floor(fila / 3) * 3; columnaCuadrante = Math.floor(columna / 3) * 3; if (tabla[fila][columna] == 0) { tabla[fila][columna] = numero; numero++; } } return tabla; } /* Crear una tabla en el documento con el sudoku generado */ function crearTabla(tabla) { var tablaHTML = document.createElement("table"); for (var i = 0; i < 9; i++) { var fila = document.createElement("tr"); for (var j = 0; j < 9; j++) { var celda = document.createElement("td"); celda.innerHTML = tabla[i][j]; fila.appendChild(celda); } tablaHTML.appendChild(fila);
[Expand Post] } document.body.appendChild(tablaHTML); } crearTabla(generarSudoku()); Me parece que el truco con esto es ir pidiéndole que genere funciones individuales en lugar de que intente hacer todo de una. Pensaba grabar un vídeo mostrando que cosas recomendaba para el tetris pero no tuve mucha suerte (Copilot congela el editor luego de que me pongo a grabar). Voy a ver si con las demás cosas que sugirieron me va mejor (quizás también pruebe haciendo algunas cosas de tu imagen). Por cierto, estaba viendo lo de https://www.youtube.com/watch?v=L0QWvectObQ y en un momento menciona que ahora tienes dos meses de prueba gratis con Copilot sin tener que esperar quien sabe cuanto a que te acepten en la beta anticipada, así que posiblemente lo pueda seguir usando con alguna de mis cuentas luego del 22 de agosto (ya les contare como me va con eso).
(237.23 KB 1280x689 Ransomware en Go.png)

>>209 También se me hizo raro eso, aunque quizás la "referencia" se deba a que según https://es.wikipedia.org/wiki/Linaro se trata de una organización que ha colaborado con Ubuntu y otras distribuciones. >>210 No iba pedirle a Copilot que genere un ransomware directamente (sino me puedo arriesgar a un baneo por estar haciendo virus) pero teniendo en cuenta lo que comente mas arriba, se me ocurrió dividir el trabajo en las siguientes tareas: 1. Listar los archivos .docx, .jpg, .txt y .pdf de manera recursiva (aunque lo de recursivo parece que no lo entendió bien por lo que tuve que ajustar eso por mi cuenta). 2. Cifrar un archivo con AES y eliminar el original. 3. Generar un LEEME* avisando que los archivos fueron secuestrados. 4. Unir todo lo anterior (esto ultimo lo tuve que hacer yo). En un principio intente hacerlo en C++, pero sin importar que pida, Copilot siempre me escupe una lista interminable de #includes, así que lo hice en Go tal como pueden ver en la imagen. >inb4 muh pasa el código completo/programa compilado Ni creas que voy a dejar que te vengues de tu ex novia o tu jefe con mi trabajo a menos que me paguen pero realmente no se ve tan difícil hacer uno de estos programas (de ahí a que no te lo reconozcan los antivirus ya es otra historia). No he intentado compilar el código para probarlo (ni pienso hacerlo) pero si lo estoy interpretando bien, lo que hace es listar los archivos docx, jpg, txt y pdf, crear uno nuevo pero cifrado (por ejemplo, archivo.jpg.aes) y borrar el original para luego hacer un LEEME.txt al finalizar. * Si bien dije que quería que creara el archivo en el escritorio, Copilot no supo a que me refería y por ende lo genera en el mismo directorio en donde se esta ejecutando el programa.
Aproveche para retomar lo que intente hacer en >>200 para dibujar el logo de Hispa, y esta vez conseguí mejores resultados: import turtle RADIUS = 100 tortuga = turtle.Turtle() # Dibujar un circulo de color rojo y relleno rojo tortuga.fillcolor("red") tortuga.begin_fill() tortuga.penup() tortuga.sety(tortuga.ycor() - RADIUS) tortuga.pendown() tortuga.circle(100) tortuga.end_fill() # lift the pen so no line is drawn tortuga.penup() tortuga.sety(tortuga.ycor() + (RADIUS/10)) tortuga.setx(tortuga.xcor() - (RADIUS/2.5)) # put pen down now (if you need to) tortuga.pendown() tortuga.pencolor("yellow") # Colocar ñ con fuente Piximisa tortuga.write("ñ", font=("Piximisa", 120, "normal")) # Finalizar el dibujo tortuga.hideturtle() turtle.done() # Fin del programa Eso si, la parte de cambiar el color a amarillo, lo que usa la variable RADIUS y las lineas con comentarios en ingles son cosas que tuve que investigar por mi cuenta, así como ir probando distintos valores en setx() y sety() hasta conseguir que la tortuga fuera hasta el centro del circulo para agregar la ñ. Digo todo esto para dejar en claro que Copilot no es una varita mágica que genera cualquier cosa que te salga de los huevos (imagino que otra historia seria si lo hubieran entrenado también con las preguntas y respuesta de Stack Overflow y sitios similares). Aun así admito que tiene su utilidad para simplificar algunas partes del desarrollo. >>211 En el archivo catalogo.cpp.txt tienes lo que llegue a hacer, pero al intentar compilarlo muestra varios errores (quizás después intente arreglarlos). En este caso quise variar un poco y comenzar con un hola mundo en wxWidgets (el cual por alguna razón me genero las cadenas en ingles aun cuando se lo pedí en español). Luego agregue unos structs y arrays para manejar los datos de algunos archivos (aunque cuando le pedí que hiciera el de una película porno no mostró sugerencias) para finalmente meterle los labels y textboxes junto con unos botones para hacer altas, bajas y modificaciones (los cuales no hacen nada). Desgraciadamente Copilot no pudo generar ninguna función para extraer los metadatos, aun cuando le indicaba que usara una librería concreta como id3lib.
Pidele que cree un sistema operativo por los kekes.
>>216 Al comenzar a escribir un comentario con la frase "un sistema operativo" me dio la siguiente sugerencia para completarlo: /* Un sistema operativo Linux es una plataforma de software libre, basada en un kernel, que permite a los usuarios ejecutar programas de forma independiente de la arquitectura de hardware. */ También me muestra esta otra sugerencia en italiano (por alguna razón): /* Un sistema operativo Linux ha una funzione chiamata fork(), che crea un nuovo processo. La funzione fork() restituisce un valore intero: -1 se si verifica un errore; 0 se il processo figlio è stato creato; >0 se il processo padre è stato creato. Il processo padre deve eseguire la funzione printf() per stampare il valore di ritorno della funzione fork(). Escribiéndolo en ingles obtengo esto: /* A operative system program that prints the current date and time. */ /* A operative system call to print a string */ Pero en las recomendaciones de código me salen un montón de includes que no llevan a nada (voy a ver si puedo dividir esto en tareas simples tal como hice con >>214 y el catalogo en >>215). Por lo que he podido notar parece que Copilot no funciona bien con C/C++ a menos que sea algo muy concreto que la IA ya conozca de antemano (como un hola mundo o funciones simples) o que tengas código ya hecho en el cual basarse, de lo contrario casi siempre manda #include <algunamierda.h> a lo pendejo. Por los "kekes" se me ocurrió probar con PHP y me dio las sugerencias del archivo adjunto (no sabia cual elegir así que las copie todas tal como las muestra Copilot). ¿Se les ocurre algún otro lenguaje en el que le pueda hacer un sistema operativo?
>>200 Pídele que haga algo gráfico con 3d en Java, a ver si con suerte explota
>>217 >voy a ver si puedo dividir esto en tareas simples Luego de consultar un par de artículos (los cuales dejare mas abajo para su deleite), lo que se necesita para tener un sistema operativo mínimamente funcional son dos cosas: 1. Un loader que entre al modo protegido y luego llame a una función. 2. La función en cuestión. Para lo primero solo encontré código en Assembler y debido a que Copilot no lo reconoce, entonces no pude generar uno de estos (si alguien sabe como hacerlo en C o C++ avise). La función principal no fue tan difícil (aunque no estuvo libre de desafíos). Como de costumbre les dejo el código: #include <types.h> /* Acceso a la memoria de video a travez de la direccion de memoria */ void *video = (void *)0xB8000; /* Funcion kekmain */ void kekmain() { /* Escribir un mensaje en la pantalla que diga "Bienvenido a kekOS, el mejor OS de la historia escrito por un chanero y su inteligencia artificial.\n¿Y ahora que?" */ *(char *)video = 'B'; *(char *)(video + 1) = 'i'; *(char *)(video + 2) = 'e'; *(char *)(video + 3) = 'n'; *(char *)(video + 4) = 'v'; *(char *)(video + 5) = 'e'; *(char *)(video + 6) = 'n'; *(char *)(video + 7) = 'd'; *(char *)(video + 8) = 'o'; *(char *)(video + 9) = ' '; *(char *)(video + 10) = 'a'; *(char *)(video + 11) = ' '; *(char *)(video + 12) = 'k'; *(char *)(video + 13) = 'e'; *(char *)(video + 14) = 'k'; *(char *)(video + 15) = 'O'; *(char *)(video + 16) = 'S'; *(char *)(video + 17) = ','; *(char *)(video + 18) = ' '; *(char *)(video + 19) = 'e'; *(char *)(video + 20) = 'l'; *(char *)(video + 21) = ' '; *(char *)(video + 22) = 'm'; *(char *)(video + 23) = 'e'; *(char *)(video + 24) = 'j'; *(char *)(video + 25) = 'o'; *(char *)(video + 26) = 'r'; *(char *)(video + 27) = ' '; *(char *)(video + 28) = 'O'; *(char *)(video + 29) = 'S'; *(char *)(video + 30) = ' '; *(char *)(video + 31) = 'd';
[Expand Post] *(char *)(video + 32) = 'e'; *(char *)(video + 33) = ' '; *(char *)(video + 34) = 'l'; *(char *)(video + 35) = 'a'; *(char *)(video + 36) = ' '; *(char *)(video + 37) = 'h'; *(char *)(video + 38) = 'i'; *(char *)(video + 39) = 's'; *(char *)(video + 40) = 't'; *(char *)(video + 41) = 'o'; *(char *)(video + 42) = 'r'; *(char *)(video + 43) = 'i'; *(char *)(video + 44) = 'a'; *(char *)(video + 45) = ' '; *(char *)(video + 46) = 'e'; *(char *)(video + 47) = 's'; *(char *)(video + 48) = 'c'; *(char *)(video + 49) = 'r'; *(char *)(video + 50) = 'i'; *(char *)(video + 51) = 't'; *(char *)(video + 52) = 'o'; *(char *)(video + 53) = ' '; *(char *)(video + 54) = 'p'; *(char *)(video + 55) = 'o'; *(char *)(video + 56) = 'r'; *(char *)(video + 57) = ' '; *(char *)(video + 58) = 'u'; *(char *)(video + 59) = 'n'; *(char *)(video + 60) = ' '; *(char *)(video + 61) = 'c'; *(char *)(video + 62) = 'h'; *(char *)(video + 63) = 'a'; *(char *)(video + 64) = 'n'; *(char *)(video + 65) = 'e'; *(char *)(video + 66) = 'r'; *(char *)(video + 67) = 'o'; *(char *)(video + 68) = ' '; *(char *)(video + 69) = 'y'; *(char *)(video + 70) = ' '; *(char *)(video + 71) = 's'; *(char *)(video + 72) = 'u'; *(char *)(video + 73) = ' '; *(char *)(video + 74) = 'i'; *(char *)(video + 75) = 'n'; *(char *)(video + 76) = 't'; *(char *)(video + 77) = 'e'; *(char *)(video + 78) = 'l'; *(char *)(video + 79) = 'i'; *(char *)(video + 80) = 'g'; *(char *)(video + 81) = 'e'; *(char *)(video + 82) = 'n'; *(char *)(video + 83) = 'c'; *(char *)(video + 84) = 'i'; *(char *)(video + 85) = 'a'; *(char *)(video + 86) = ' '; *(char *)(video + 87) = 'a'; *(char *)(video + 88) = 'r'; *(char *)(video + 89) = 't'; *(char *)(video + 90) = 'i'; *(char *)(video + 91) = 'f'; *(char *)(video + 92) = 'i'; *(char *)(video + 93) = 'c'; *(char *)(video + 94) = 'i'; *(char *)(video + 95) = 'a'; *(char *)(video + 96) = 'l'; *(char *)(video + 97) = '.'; *(char *)(video + 98) = '\n'; *(char *)(video + 99) = '¿'; *(char *)(video + 100) = 'Y'; *(char *)(video + 101) = ' '; *(char *)(video + 102) = 'a'; *(char *)(video + 103) = 'h'; *(char *)(video + 104) = 'o'; *(char *)(video + 105) = 'r'; *(char *)(video + 106) = 'a'; *(char *)(video + 107) = ' '; *(char *)(video + 108) = 'q'; *(char *)(video + 109) = 'u'; *(char *)(video + 110) = 'e'; *(char *)(video + 111) = '?'; *(char *)(video + 112) = '\n'; } >inb4 ¿Que es esta mierda? Un sistema operativo super básico que hace lo siguiente: * Acceder a la memoria de vídeo (aunque me llevo un rato hasta lograr que Copilot creara el puntero en cuestión). * Define la función kekmain(). * Escribe una pendejada en la pantalla accediendo a la memoria de vídeo directamente. Por cierto, lo de "el mejor OS de la historia" me lo sugirió Copilot, pero lo deje por que me pareció bonito. >inb4 muh ¿Y por que no usaste printf o similar? Por que según leí esas son cosas que dependen del sistema operativo, pero al estar haciendo uno desde cero entonces te toca a ti definir esas funciones. >inb4 ¿No habría sido mas fácil hacer un bucle sobre un puntero char en lugar de meter los caracteres uno por uno? Si, pero a Copilot le dio retraso y lo hizo así, aunque supongo que primero podría haber definido un puntero con la frase yo mismo y luego decirle que itere sobre el mismo para crear el bucle. Solo para aclarar, no me genero toda la frase de una, sino que cada 4 o 5 lineas metía cualquier letra y lo tenia que ir corrigiendo. >inb4 ¿Funciona? Ni puta idea, pero lo mas probable es que no. Si quieren pueden intentar compilarlo con lo que se explica en alguno de estos artículos: https://blog.desdelinux.net/emulando-a-linus-torvalds-crea-tu-propio-sistema-operativo-desde-0-i/ https://www.elladodelmal.com/2013/09/prescinde-de-tu-sistema-operativo-si.html >>219 Mas tarde lo pruebo, aunque se me hace que solo va a generar el código para dibujar el gráfico con alguna librería random.
>>220 >podría haber definido un puntero con la frase yo mismo y luego decirle que itere sobre el mismo para crear el bucle Se me ocurrió probar con eso luego de postear y al menos ahora quedo mas compacto: #include <types.h> /* Acceso a la memoria de video a travez de la direccion de memoria */ void *video = (void *)0xB8000; /* Funcion kekmain */ void kekmain() { /* Crear un puntero que diga "Bienvenido a kekOS, el mejor OS de la historia escrito por un chanero con la ayuda de una inteligencia artificial.\n¿Y ahora que?" */ char *msg = "Bienvenido a kekOS, el mejor OS de la historia escrito por un chanero con la ayuda de una inteligencia artificial.\n¿Y ahora que?"; /* Escribir un mensaje en la pantalla iterando sobre el puntero */ for (int i = 0; i < strlen(msg); i++) *(char *)(video + i) = msg[i]; } Aunque es casi seguro que si lo intento compilar mínimo strlen va a dar problemas ya que no estoy usando la librería estándar. >>219 Esto es lo mejor que llega a generar: /* Draw 3D plot of a function */ import java.applet.*; import java.awt.*; import java.awt.event.*; import java.awt.image.*; import java.awt.font.*; import java.awt.color.*; // ColorSpace import java.awt.geom.*; // AffineTransform import java.sql.*; import java.io.*; import java.net.*; import java.util.*; import java.awt.List; import java.awt.print.*; import java.awt.geom.*; import java.awt.geom.Point2D.*; import java.lang.Math; public class test extends Applet implements Runnable, MouseListener, MouseMotionListener { Thread th; int width, height; int xmin, xmax, ymin, ymax; int x1, y1, x2, y2; int x, y; int xold, yold; int x0, y0; int x00, y00;
[Expand Post] int x000, y000; int x0000, y0000; int x00000, y00000; int x000000, y000000; int x0000000, y0000000; int x00000000, y00000000; int x000000000, y000000000; int x0000000000, y0000000000; int x00000000000, y00000000000; int x000000000000, y000000000000; int x0000000000000, y0000000000000; int x00000000000000, y00000000000000; int x000000000000000, y000000000000000; int x0000000000000000, y0000000000000000; int x00000000000000000, y00000000000000000; int x000000000000000000, y000000000000000000; int x0000000000000000000, y0000000000000000000; int x00000000000000000000, y00000000000000000000; int x000000000000000000000, y000000000000000000000; int x0000000000000000000000, y0000000000000000000000; int x00000000000000000000000, y00000000000000000000000; int x000000000000000000000000, y000000000000000000000000; int x0000000000000000000000000, y0000000000000000000000000; Si se lo pido en español devuelve mas o menos la misma mierda. No quería quedarme solo con eso así que intente siendo especifico con lo que quiero y conseguí algo mas prometedor: /* Dibujar graficos de una funcion con una sola variable usando la libreria jfreechart */ import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.geom.Ellipse2D; import java.awt.geom.Line2D; import java.awt.geom.Rectangle2D; import java.awt.geom.RectangularShape; import java.awt.geom.RoundRectangle2D; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.logging.Level; import java.util.logging.Logger; import javax.imageio.ImageIO; import javax.swing.JFrame; import javax.swing.JPanel; import org.jfree.chart.ChartFactory; import org.jfree.chart.ChartPanel; import org.jfree.chart.JFreeChart; import org.jfree.chart.plot.PlotOrientation; import org.jfree.chart.plot.XYPlot; import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer; import org.jfree.data.xy.XYDataset; import org.jfree.data.xy.XYSeries; import org.jfree.data.xy.XYSeriesCollection; import org.jfree.ui.ApplicationFrame; import org.jfree.ui.RefineryUtilities; public class test extends JFrame { public test(String title) { super(title); setSize(500, 500); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setContentPane(new ChartPanel(createChart(createDataset()))); setVisible(true); } private static JFreeChart createChart(XYDataset dataset) { JFreeChart chart = ChartFactory.createXYLineChart( "Grafico de funcion", "X", "Y", dataset, PlotOrientation.VERTICAL, true, true, false ); XYPlot plot = (XYPlot) chart.getPlot(); XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(); renderer.setSeriesPaint(0, Color.RED); renderer.setSeriesPaint(1, Color.BLUE); renderer.setSeriesPaint(2, Color.GREEN); renderer.setSeriesPaint(3, Color.YELLOW); renderer.setSeriesPaint(4, Color.ORANGE); renderer.setSeriesPaint(5, Color.PINK); renderer.setSeriesPaint(6, Color.CYAN); renderer.setSeriesPaint(7, Color.MAGENTA); renderer.setSeriesPaint(8, Color.BLACK); renderer.setSeriesPaint(9, Color.GRAY); renderer.setSeriesPaint(10, Color.LIGHT_GRAY); renderer.setSeriesPaint(11, Color.DARK_GRAY); renderer.setSeriesPaint(12, Color.WHITE); renderer.setSeriesPaint(13, Color.BLUE); renderer.setSeriesPaint(14, Color.RED); renderer.setSeriesPaint(15, Color.GREEN); renderer.setSeriesPaint(16, Color.YELLOW); renderer.setSeriesPaint(17, Color.ORANGE); renderer.setSeriesPaint(18, Color.PINK); renderer.setSeriesPaint(19, Color.CYAN); renderer.setSeriesStroke(0, new java.awt.BasicStroke(2.0f)); renderer.setSeriesStroke(1, new java.awt.BasicStroke(2.0f)); renderer.setSeriesStroke(2, new java.awt.BasicStroke(2.0f)); renderer.setSeriesStroke(3, new java.awt.BasicStroke(2.0f)); renderer.setSeriesStroke(4, new java.awt.BasicStroke(2.0f)); renderer.setSeriesStroke(5, new java.awt.BasicStroke(2.0f)); renderer.setSeriesStroke(6, new java.awt.BasicStroke(2.0f)); plot.setRenderer(renderer); }
>>219 Pídele >Operating system barebone Creo que le va a ser más fácil a la IA entender qué es lo que quieres. >¿Se les ocurre algún otro lenguaje en el que le pueda hacer un sistema operativo? C, C++, Pascal, D, Go, y Rust. https://wiki.osdev.org/Category:Languages
>>220 Podrías haberle pedido que te defina un strcpy y simplificabas el código. char *strcpy(char *restrict dest, const char *src) { const char *saved = dest; while (*src) { *dest++ = *src++; } dst = 0; return saved; } /* Acceso a la memoria de video a travez de la direccion de memoria */ void *video = (void *)0xB8000; /* Funcion kekmain */ void kekmain() { /* Escribir un mensaje en la pantalla que diga "Bienvenido a kekOS, el mejor OS de la historia escrito por un chanero y su inteligencia artificial.\n¿Y ahora que?" */ strcpy(video,"Bienvenido a kekOS, el mejor OS de la historia escrito por un chanero y su inteligencia artificial.\n¿Y ahora que?"); } >>inb4 ¿Funciona? >Ni puta idea, pero lo mas probable es que no. Sí funciona, si le haces un cargador y lo pruebas en qemu, te va mosttrar ese texto cuando cargue el sistema. Tienes que hacer que el cargador apunte a kekmain() Fijate en "Bootstrap Assembly" https://wiki.osdev.org/Bare_Bones >>221 No puedes hacer eso porque primero tienes que crear la cabecera types.h y luego definir strlen(). Cuando creas un sistema operativo desde cero, no tienes acceso a ninguna librería, tú tienes que crear cada una de la librerías y funciones que vas a usar.
>>222 >>Operating system barebone En C no conseguí nada, pero con Go en cambio me genero esta cosa: /* Operative system based on Go */ package main import ( "fmt" "os" "os/exec" "path/filepath" "strings" ) func main() { if len(os.Args) < 2 { fmt.Println("Usage: go run test.go <command>") os.Exit(1) } switch os.Args[1] { case "install": install() case "run": run() default: fmt.Println("Unknown command:", os.Args[1]) os.Exit(1) } } func install() { fmt.Println("Installing...") os.MkdirAll("/usr/local/bin", 0755) os.Rename(os.Args[0], "/usr/local/bin/go") } func run() { fmt.Println("Running...") cmd := exec.Command("/usr/local/bin/go", os.Args[2:]...) cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Run(); err != nil { fmt.Println(err) os.Exit(1) } }
[Expand Post]Lo de "based in Go" lo deje a sugerencia de Copilot para ver hasta donde me llevaba. Si alguien lo quiere probar, recomiendo que sea dentro de una maquina virtual (no me da mucha confianza que intente tocar cosas del sistema). >C, C++, Pascal, D, Go, y Rust. En la noche seguiré probando con alguno de esos lenguajes (y con cualquier otra cosa que surja por aquí). >>223 >Podrías haberle pedido que te defina un strcpy Puede ser, C y C++ nunca fueron mi fuerte por lo que no se me había ocurrido. >Sí funciona Bueno saberlo. >No puedes hacer eso porque primero tienes que crear la cabecera types.h y luego definir strlen(). Lo de poner #include <types.h> era para que Copilot no escupiera una lista interminable de includes (sospecho que es un bug de la IA). Ademas, tampoco pensaba compilar el código ya que lo hice mas para ver cuales son los alcances de esta herramienta.
(1.54 KB baru.rs.txt)

>>223 >Podrías haberle pedido que te defina un strcpy Curioso, al pedirle eso me genero una función casi idéntica a la tuya (pero sin el return): /* Funcion para copiar una cadena de caracteres hacia un puntero */ void strcpy(char *dest, char *src) { while (*src) *dest++ = *src++; *dest = '\0'; } >>224 >En la noche seguiré probando con alguno de esos lenguajes Y aquí están mis resultados. El primero en Go: /* Operating system bare metal programming example. */ package main import ( "fmt" "os" "os/exec" "syscall" ) func main() { if len(os.Args) < 2 { fmt.Println("Usage:", os.Args[0], "command [args...]") os.Exit(1) } cmd := exec.Command(os.Args[1], os.Args[2:]...) cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr cmd.SysProcAttr = &syscall.SysProcAttr{ Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS, } if err := cmd.Run(); err != nil { fmt.Println(err) os.Exit(1) } } Otro mas (también en Go): /* Operating system barebones. */ package main
[Expand Post]import ( "fmt" "os" ) func main() { fmt.Println(os.Args[0]) } En Pascal (aunque también podría ser Delphi ya que ambos lenguajes tienen archivos con la misma extensión): {* Operating system barebones. } {$IFDEF WINDOWS} uses Windows; {$ENDIF} {$IFDEF LINUX} uses Libc; {$ENDIF} {$IFDEF DARWIN} uses MacOSAll; {$ENDIF} {$IFDEF ANDROID} uses Androidapi.JNI.Os, Androidapi.JNI.JavaTypes, Androidapi.Helpers; {$ENDIF} {$IFDEF ANDROID} function GetEnvironmentVariable(const Name: string; var Value: string): Boolean; var JName: JString; JValue: JString; begin JName := StringToJString(Name); JValue := TJni.Java.lang.System.getenv(JName); Result := JValue <> nil; if Result then Value := JStringToString(JValue); JNI_FreeString(JName); JNI_FreeString(JValue); end; {$ENDIF} {$IFDEF WINDOWS} function GetEnvironmentVariable(const Name: string; var Value: string): Boolean; var Len: Integer; begin Len := GetEnvironmentVariable(PChar(Name), nil, 0); if Len > 0 then begin SetLength(Value, Len - 1); GetEnvironmentVariable(PChar(Name), PChar(Value), Len); end; Result := Len > 0; end; {$ENDIF} {$IFDEF LINUX} function GetEnvironmentVariable(const Name: string; var Value: string): Boolean; var Len: Integer; begin Len := GetEnvironmentVariable(PChar(Name), nil, 0); if Len > 0 then begin SetLength(Value, Len - 1); GetEnvironmentVariable(PChar(Name), PChar(Value), Len); end; Result := Len > 0; end; {$ENDIF} {$IFDEF DARWIN} function GetEnvironmentVariable(const Name: string; var Value: string): Boolean; var Len: Integer; begin Len := GetEnvironmentVariable(PChar(Name), nil, 0); if Len > 0 then begin SetLength(Value, Len - 1); GetEnvironmentVariable(PChar(Name), PChar(Value), Len); end; Result := Len > 0; end; {$ENDIF} Rust: /* Operative System bare metal programming */ use core::panic::PanicInfo; #[panic_handler] fn panic(_info: &PanicInfo) -> ! { loop {} } #[no_mangle] pub extern "C" fn _start() -> ! { panic!(); } #[lang = "eh_personality"] #[no_mangle] pub extern "C" fn eh_personality() {} #[lang = "eh_unwind_resume"] #[no_mangle] pub extern "C" fn eh_unwind_resume() {} #[lang = "panic_fmt"] #[no_mangle] pub extern "C" fn panic_fmt() -> ! { loop {} } #[lang = "eh_unwind_init"] #[no_mangle] pub extern "C" fn eh_unwind_init() {} Lo que obtengo al pedirle un barebone directamente (tambien en Rust): /* Operative System barebones */ use std::io::{self, Read}; use std::mem; use std::ptr; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::Arc; use std::thread; use std::time::Duration; use log::{debug, error, info, warn}; use log::LevelFilter; use crate::{ arch::{ x86::{ instructions::{instructions::*, *}, registers::{registers::*, *}, }, x86_64::{ instructions::{instructions::*, *}, registers::{registers::*, *}, }, }, kernel::{ memory::{ allocator::{Allocator, AllocatorConfig}, frame_allocator::FrameAllocator, memory_manager::MemoryManager, page_table::{PageTable, PageTableConfig}, PhysicalAddress, VirtualAddress, }, process::{Process, ProcessConfig}, scheduler::{Scheduler, SchedulerConfig}, system::System, }, memory::{ allocator::{AllocatorConfig, AllocatorType}, frame_allocator::FrameAllocatorConfig, memory_manager::MemoryManagerConfig, page_table::{PageTableConfig, PageTableType}, }, process::{ProcessConfig, ProcessType}, scheduler::{SchedulerConfig, SchedulerType}, system::SystemConfig, }; const KERNEL_STACK_SIZE: usize = 0x1000; const KERNEL_STACK_ADDRESS: usize = 0xffff_ffff_ffff_f000; const KERNEL_STACK_ADDRESS_END: usize = KERNEL_STACK_ADDRESS + KERNEL_STACK_SIZE; const KERNEL_STACK_ADDRESS_END_ALIGNED: usize = KERNEL_STACK_ADDRESS_END & !0xfff; const KERNEL_HEAP_SIZE: usize = 0x1000; const KERNEL_HEAP_ADDRESS: usize = 0xffff_ffff_ffff_f000; const KERNEL_HEAP_ADDRESS_END: usize = KERNEL_HEAP_ADDRESS + KERNEL_HEAP_SIZE; const KERNEL_HEAP_ADDRESS_END_ALIGNED: usize = KERNEL_HEAP_ADDRESS_END & !0xfff; const KERNEL_MEMORY_SIZE: usize = 0xffff_ffff_ffff_f000; const KERNEL_MEMORY_ADDRESS: usize = 0xffff_ffff_ffff_f000; const KERNEL_MEMORY_ADDRESS_END: usize = KERNEL_MEMORY_ADDRESS + KERNEL_MEMORY_SIZE; const KERNEL_MEMORY_ADDRESS_END_ALIGNED: usize = KERNEL_MEMORY_ADDRESS_END & !0xfff; const KERNEL_MEMORY_STACK_SIZE: usize = 0x1000; const KERNEL_MEMORY_STACK_ADDRESS: usize = 0xffff_ffff_ffff_f000; const KERNEL_MEMORY_STACK_ADDRESS_END: usize = KERNEL_MEMORY_STACK_ADDRESS + KERNEL_MEMORY_STACK_SIZE; const KERNEL_MEMORY_STACK_ADDRESS_END_ALIGNED: usize = KERNEL_MEMORY_STACK_ADDRESS_END & !0xfff; const KERNEL_MEMORY_HEAP_SIZE: usize = 0x1000; const KERNEL_MEMORY_HEAP_ADDRESS: usize = 0xffff_ffff_ffff_f000; const KERNEL_MEMORY_HEAP_ADDRESS_END: usize = KERNEL_MEMORY_HEAP_ADDRESS + KERNEL_MEMORY_HEAP_SIZE; const KERNEL_MEMORY_HEAP_ADDRESS_END_ALIGNED: usize = KERNEL_MEMORY_HEAP_ADDRESS_END & !0xfff; const KERNEL_MEMORY_HEAP_SIZE_2: usize = 0x1000; const KERNEL_MEMORY_HEAP_ADDRESS_2: usize = 0xffff_ffff_ffff_f000; const KERNEL_MEMORY_HEAP_ADDRESS_END_2: usize = KERNEL_MEMORY_HEAP_ADDRESS_2 + KERNEL_MEMORY_HEAP_SIZE_2; const KERNEL_MEMORY_HEAP_ADDRESS_END_ALIGNED_2: usize = KERNEL_MEMORY_HEAP_ADDRESS_END_2 & !0xfff; const KERNEL_MEMORY_HEAP_SIZE_3: usize = 0x1000; const KERNEL_MEMORY_HEAP_ADDRESS_3: usize = 0xffff_ffff_ffff_f000; const KERNEL_MEMORY_HEAP_ADDRESS_END_3: usize = KERNEL_MEMORY_HEAP_ADDRESS_3 + KERNEL_MEMORY_HEAP_SIZE_3; const KERNEL_MEMORY_HEAP_ADDRESS_END_ALIGNED_3: usize = KERNEL_MEMORY_HEAP_ADDRESS_END_3 & !0xfff; const KERNEL_MEMORY_HEAP_SIZE_4: usize = 0x1000; const KERNEL_MEMORY_HEAP_ADDRESS_4: usize = 0xffff_ffff_ffff_f000; const KERNEL_MEMORY_HEAP_ADDRESS_END_4: usize = KERNEL_MEMORY_HEAP_ADDRESS_4 + KERNEL_MEMORY_HEAP_SIZE_4; const KERNEL_MEMORY_HEAP_ADDRESS_END_ALIGNED_4: usize = KERNEL_MEMORY_HEAP_ADDRESS_END_4 & !0xfff; Con D no me sugiere nada (ni para hacer un hola mundo), lo mas seguro es que ni se molestaron en entrenar a Copilot con este lenguaje, aun cuando tienen mas de 5000 proyectos hechos en D según https://github.com/search?l=D&q=d&type=Repositories Por ultimo, el archivo baru.rs.txt es lo que genero cuando el autocompletado sugirió "baru" en lugar de barebone y me dio curiosidad ver que salia.
>>200 ¿Puede escribir makefiles? Pídele algo así: # Makefile for building an executable called 'program' from program.h and program.c
>>227 Ah, justo el 22. Muy tarde.


Forms
Eliminar
Informar
Respuesta rápida