Fecha y hora actual: Domingo 25 Ago 2019 04:49
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Lección 75: Distribución de aplicaciones - Línea de comandos

Responder al Tema

Índice del Foro > Programación en general > Lección 75: Distribución de aplicaciones - Línea de comandos

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Miércoles 21 Nov 2012 19:29

Título del mensaje: Lección 75: Distribución de aplicaciones - Línea de comandos

Responder citando

En la lección anterior habíamos logrado tener un sistema que antes era dependiente de la plataforma en la que había sido desarrollado y ahora no lo es. Por tanto podremos usar nuestro programa en Windows, Linux, Solaris o Mac OS X.

Es momento encones de comenzar a ver algunos aspectos acerca de la distribución de aplicaciones en Java y con esto el uso de la línea de comandos o consola.

Distribución de aplicaciones y el uso de la consola

Hasta ahora hemos utilizado nuestras aplicaciones directamente desde el IDE y no hemos visto cómo quedan generados nuestros programas y cómo ejecutarlos independientemente de NetBeans. No sería muy lindo para distribuir nuestros programas pedirle al cliente que instale NetBeans y luego ejecute el código fuente. Veamos entonces, primero, cómo ejecutar un archivo .class desde la consola.

==============================================

Compilar y ejecutar programas Java desde la consola:

Lo que en Windows se conoce como consola en Linux es Terminal (a veces también se le llama consola). Todo usuario Linux sabe abrir una consola (el que no sepa busque en Google como abrir la consola de su distribución). En Windows lo he enseñado varias veces así que no lo haré ahora.

Cuando nosotros compilamos nuestro código con NetBeans en realidad no es él quién lo compila ya que NetBeans es un IDE, no un compilador. Lo que se hace en realidad es invocar al compilador de java llamado javac (abreviación del inlgés java compiler) quién se encarga de realizar la “traducción” de un .java a un .class para cada clase existente. NetBeans configura muchas otras cosas además de invocar al compilador, por ejemplo, las carpetas donde se colocarán los archivos y demás. Por defecto, NetBeans crea una carpeta llamada NetBeansProjects en la carpeta de usuario del sistema (en Windows lo hace en Mis Documentos para XP o Documentos para Vista y 7, y en Linux suele estar en /home/nombreUsuario). Dentro de esa carpeta habrá una carpeta por cada proyecto que hayamos creado, cada una con el nombre exacto que le dimos al proyecto a la hora de crearlo. Cuando creamos clases y las guardamos, NetBeans crea dentro de la carpeta del proyecto una carpeta llamada src (igual que lo hacía el XDS para Modula) donde genera los archivos .java. Recordar que los archivos .java son solo el texto con el código fuente, bien podríamos abrirlos con el block de notas o cualquier editor básico de texto.
Cuando compilamos nuestro proyecto, NetBeans crea una carpeta llamada build y dentro de ella otra llamada classes (entre otras que ahora no nos interesan). Esta última carpeta contendrá los archivos .class del proyecto, es decir los ejecutables de la JVM (archivos .java compilados). Veremos como compilar un proyecto por línea de comandos, como si no tuviéramos NetBeans ni ningún otro IDE.

Crearemos una carpeta en la que trabajar, en mi caso es U:\Java (sigo trabajando en Windows). Abrimos un editor de texto simple como el Block de notas y le ponemos el código fuente del HolaMundo. Guardamos ese archivo con extención .java. Si aún tienen en su carpeta de proyectos el proyecto HolaMundo pueden copiar y pegar el archivo HolaMundo.java desde allí hacia la nueva carpeta que se hayan creado para trabajar ahora. Como ven, no hace falta usar NetBeans, con un simple editor de texto basta (claro que para un programa tan simple, si fuera complejo nos moriríamos chequeando sintaxis así). Ahora abrimos una consola y nos movemos al directorio seleccionado. Tanto en Windows como en Linux el comando para cambiar de directorio es CD <rutaDelDirectorio>:



En Windows no es sensible a mayúsculas y minúsculas, en Linux sí. Bien, estando en el directorio donde hemos guardado el archivo HolaMundo.java escribimos:

Código:
javac HolaMundo.java


Con eso hemos invocado al compilador de Java y le hemos dicho que debe compilar al archivo HolaMundo.java. Noten que he incluido la extención en el nombre del archivo, eso no es trivial. Si no existen errores de sintaxis verán algo como lo de la imagen, es decir, nada; de lo contrario se nos mostrará el error que tuvimos. Si no está bien configurado el PATH no podrán invocar nada por línea de comandos, por tanto deberán ir al principio de este tutorial para ver como corregir eso.

Tendremos ahora, en la misma carpeta donde guardamos a HolaMundo.java un nuevo archivo llamado HolaMundo.class. Para ejecutar el programa escribimos:

Código:
java HolaMundo




El comando java invoca a la máquina virtual de Java. Al escribir el nombre del programa a continuación (sin extención .class) la máquina virtual ejecuta el programa. En este caso vemos simplemente la salida “Hola Mundo”. Si ustedes tuvieran configurado su sistema operativo para que abra directamente los archivos .class con la JVM bastaría hacer doble clic sobre el archivo y se abriría el programa. Esto no suele hacerse y por tanto no lo haremos. Quién quiera experimentar bienvenido sea.

Ahora quiero que entren en su carpeta de NetBeans, luego en la carpeta del proyecto NominaPersonas --> src y copien los archivos .java contenidos allí hacia la carpeta en la que estamos trabajando ahora. Básicamente tomaremos los archivos: Persona.java, ListaPersonas.java y NominaPersonas.java y los copiaremos a nuestra carpeta:



Para compilar mediante la consola un sistema que tiene varias clases podemos, compilarlas de a una como hicimos con HolaMundo, o bien, todas en una misma línea. Lo único que hay que hacer es escribir el comando javac y luego dar los nombres de las clases a compilar separados por espacios:



Muchas veces puede resultar importante el orden en que escribimos los nombres de las clases teniendo que respetar el orden de dependencias. En este caso he escrito primero a la clase Persona porque es independiente, luego a ListaPersonas porque depende de Persona y luego a NominaPersonas porque depende de ListaPersonas. Típicamente esto no implica un problema pudiendo pasar los argumentos en cualquier orden, pero puede resultar útil tenerlo en cuenta.

Para ejecutar el sistema tenemos que llamar a java pasando el nombre de la clase principal, es decir, la que tiene método main; en este caso es NominaPersonas:



Como ven, se ha iniciado el sistema NominaPersonas.

========================================

Distribución con archivos JAR:

Todo muy lindo, como compilar y ejecutar desde línea de comandos. Ahora bien, si yo quiero dar mi programa Java a un amigo ¿tengo que darle todos los .class y decirle como ejecutar desde consola? Sería mucho mejor si tuviéramos un archivo que pudiéramos abrir directamente. Bien, esto resulta “relativamente” sencillo con NetBeans. Las aplicaciones Java suelen distribuirse mediante archivos .jar. Cuando nosotros ya hemos probado nuestro programa y estamos listos para distribuirlo podemos valernos de NetBeans para obtener un archivo jar (hacerlo desde línea de comandos suele resultar complicado y dar algunos dolores de cabeza, se los digo por experiencia).

Vayamos en NetBeans a cualquiera de nuestros proyectos terminados, en mi caso iré a NominaPeronas. Presionemos en Clean and Build (Limpiar y construir). Para esto último debe estar asignado el proyecto com o proyecto principal. Si no es así, hacemos clic derecho sobre él y elegimos Limpiar y construir:



Esperamos a que se complete el proceso (no suele tardar mucho). Tal vez hayan notado que otra de las carpetas existentes dentro de las carpetas de los proyectos es una llamada dist (abreviación de distribution o distribución). Cada vez que ejecutamos desde NetBeans la acción de Limpiar y construir esta carpeta es eliminada y reconstruida. ¿Qué hay allí? Pues justamente todo lo necesario para la distribución del proyecto, esto es:

  • Un archivo README.txt que tiene información para nosotros desarrolladores. Nunca nadie lo lee. No es necesario para ejecutar el programa.
  • Un archivo .jar con el mismo nombre del proyecto.
  • Una carpeta llamada lib que contiene las librerías externas utilizadas por el sistema. En el caso de NominaPersonas no existe tal carpeta porque no hemos usado nada de terceros, luego veremos algún sistema que sí lo haga.


Un archivo jar es un paquete que en su interior contiene todas las clases que componen al sistema. Un archivo jar puede abrirse con cualquier programa de compresión como WinRAR .En Linux podemos abrirlos directamente y ver su contenido. Si abrimos NominaPersonas.jar con WinRAR veremos esto:



Como pueden observar están todos los archivos .class en su interior y una carpeta muy importante llamada META-INF. Dentro de esta carpeta se encuentra un archivo conocido como archivo de manifiesto. No es más que un archivo de texto que contendrá información crucial para la JVM. Si abrimos este veremos el texto:

Código:
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.8.3
Created-By: 1.6.0_23-b05 (Sun Microsystems Inc.)
Class-Path:
X-COMMENT: Main-Class will be added automatically by build
Main-Class: NominaPersonas


La línea que más nos interesa es la que dice Main-Class. Esta línea indica justamente cuál es la clase principal del sistema. Por suerte NetBeans hace todo esto por nosotros, sino tendríamos que escribirlo a mano. Cerramos sin modificar nada.

Entonces el archivo .jar está listo para ser utilizado. Ahora, si ustedes dan doble clic en él o intentan ejecutarlo de alguna manera no aparecerá nada. Bien, esto es porque el programa se ejecuta en consola, no es un sistema con interfaz gráfica. En Windows, típicamente al instalar JRE el sistema es configurado para abrir los archivos .jar con la máquina virtual de modo que al hacer doble clic este se abre (si no es como este caso que no tiene interfaz gráfica). En Linux esto no es así en casi ninguna distribución, de modo que habría que ejecutar el sistema o bien, dar la orden por consola. Los usuarios de Linux no tendrán problemas en escribir un comando por consola para lanzar una aplicación porque esto es habitual en estos sistemas, sin embargo en Windows no lo es tanto. Para cambiar esto en un sistema Windows simplemente hacemos clic derecho sobre el .jar, luego elegimos Abrir con y, al ver este cuadro eligen examinar:



Van a la carpeta donde instalaron Java, típicamente en Archivos de Programa-->Java-->jreX donde X es el número de la versión de Java instalada. Allí esta la carpeta bin y dentro de ella el programa javaw. Lo seleccionamos, luego marcamos la casilla Utilizar siempre el programa seleccionado… y damos en aceptar. Con eso el ícono del .jar cambiará a la taza de café.

Bien, más allá de esto, seguimos con el problema de que nuestro NominaPersonas.jar no se abrirá directamente. Cuando un programa Java se ejecuta en consola debe ser abierto mediante la consola. El comando es sencillo:

Código:
java –jar <direccionDelJAR>


Si ya estamos en el directorio que contiene al JAR va solo el nombre del archivo, sino va toda la dirección, veamos ambos casos:



En este caso, mi archivo JAR estaba ubicado en la carpeta U:\Java, como ya estaba posicionado en dicho directorio solo puse el nombre del archivo luego de –jar y listo. Supongamos ahora que desde la consola me da pereza ejecutar el comando CD para cambiar de directorio pero quiero abrir el archivo jar ubicado en U:\Java, pues escribo esto:

Código:
java –jar U:\Java\NominaPersonas.jar




Los sistemas Java que posean interfaz gráfica pueden ser ejecutados igualmente mediante este comando. Lo que sucederá es que se ejecutará la interfaz gráfica por fuera de la consola y luego quedaremos en manos justamente de ella.

Les dejo en el siguiente enlace un archivo JAR llamado 001-BotonMensaje.jar el cual es un programa muy simple que contiene una interfaz gráfica. Quiero que los usuarios Windows logren ejecutarlo mediante un doble clic y luego, que TODOS (sin importar el sistema operativo que usen) lo ejecuten mediante la consola:

https://www.dropbox.com/sh/w6n7zvw77xtfjwj/YB2rAPfNKz

Como queda poco tiempo para seguir desarrollando aplicaciones de consola esto de la línea de comandos será usado solo para ejecutar el programa por usuarios Linux. Típicamente los usuarios Windows lograrán invocar a la máquina virtual de Java directamente al abrir el jar. Luego veremos otros aspectos de la distribución, pero por ahora es más que suficiente.

==============================================

Archivo por lotes batch:

Si a persar de todo lo visto hata ahora, por ejemplo, no queremos que de ningún modo el usuario final tenga que abrir la consola para ejecutar el JAR de NominaPersonas podemos crear un archivo batch. Existe todo un campo de programación batch que nosotros no tocaremos, solo me limitaré a ver lo que nos haga falta para nuestros sistemas.

¿Qué es un archivo batch? Es un simple archivo que contiene instrucciones directas para el sistema, instrucciones de línea de comandos. En Windows estos archivos tienen extención .bat y en Linux suele ser sh. El tema de la extención de archivos es otro mundo, pero por ahora manejemos estas.

¿Cuál es la idea? Pues escribir la instrucción que deberíamos escribir en la consola en un archvivo de modo que el usuario ejecute dicho archivo y este haga todo el trabajo. Recordemos:

Código:
java –jar NominaPersonas.jar


Abramos un editor de texto como el Block de notas y escribimos en él esa instrucción y luego lo guardamos con extención bat en Windows o sh en Linux.



Al ejecutar el archivo batch este abrirá directamente la consola y le pasará el comando que escribimos en él. Obviamente que el PATH tiene que estar bien configurado o la consola no reconocerá el comando java. Esta nueva herramienta aplica a mucho más que esto, seguro han visto estos archivos en muchos programas. Normalmente realizan configuraciones o comprobaciones del sistema.

==============================================

El argumento ARGS:

Hemos llegado a un punto en el que podemos terminar de analizar la firma del procedmiento main. Claramente podía haber hecho esto antes si, en vez de utilizar de entrada a NetBeans, hubiera decidido usar la consola; pero no lo hice porque, además de aprender a programar, quiero que el curso resulte interesante e incentivador, además, hoy día no se suele compilar o llamar a los sistemas a través de la consola. Claro está que esto es relativo al propósito del programa y a la plataforma en la que es ejecutado. En Windows estamos acostumbrados a que todo es automático. Por ejemplo, para instalar un programa me bajo el instalador, hago doble clic, presiono en NEXT unas cinco veces y espero a que se instale y configure solito. En Linux esto es un poco más complejo, tengo que ver en qué distribución estoy, qué tipo de paquete me bajé (si es deb, rpm, tar.gz, etc) y, por lo general tengo que abrir la consola, ponerme como super usuario y ejecutar uno o más comandos para lograr lanzar el programa. A veces con los paquetes rpm podemos lograr abrilos directamente al hacer clic, pero no es lo más habitual. Lo que quiero decir es, que muchas veces el invocar a un programa a través de la consola resulta útil, y, aunque para los usuarios Windows no sea lo habitual, aprender a hacerlo no estará nunca de más. Recuerden que usar la línea de comandos no es solo para técnicos o programadores Guiño

Repasemos la firma del main y lo que habíamos visto de ella:

Código:
  1. public static void main (String[] args)


  • Es público porque debe ser accesible desde fuera de la clase en que está. Concretamente será la máquina virtual de Java quién accederá a este procedimiento ni bien ejecutemos el programa.
  • Es estático porque debe existir en memoria ya al ejecutarse, sin importar si hemos creado objetos de la clase en que es declarado.
  • Es nulo (void) porque es un procedimiento, no se espera retorno alguno de él.


Entonces, sabemos que la JVM lo primero que hará una vez que hemos invocado al programa es llamar al método main. Como se estarán preguntado desde hace mucho ¿Qué es el arreglo de Strings que recibimos? O sea, tenemos un parámetro llamado args que es un arreglo de Strings. No lo hemos usado jamás, además ¿quién le pasará a main un arreglo de Strings? Pues si quién invoca a main es la JVM entonces es la JVM quién le pasará el argumento a la operación. Como es un simple parámetro, en vez de llamarse args se podría llamar miArreglo o cualquier otra cosa; es por convención que se lo llama args que es abreviación del inglés arguments que significa argumentos.

Cuando nosotros invocamos por consola a un programa Java, tal como vimos anteriormente, podemos agregar en el llamado tantos argumentos como queramos. Estos argumentos podrían bien ser comandos de entrada para especificar al programa qué debe hacer. Por ejemplo, para invocar por consola a un programa de Java nosotros escribimos:

Código:
java <nombreDelPrograma>


¿Qué es eso? Primero llamamos al programa java (la máquina virtual) que es instalado al instalar JRE, y luego le pasamos a este como argumento el nombre del programa que debe ejecutar. Dicho nombre pude ser toda una ruta completa, por tanto no es más que un String. El programa java toma ese String como argumento y lo utiliza para buscar el archivo que debe abrir y, si lo encuentra, lo ejecuta, sino nos lanzará un error y se cerrará. Otro ejemplo que sirve tanto para Windows como para linux es el comando CD que sirve para cambiar de directorio. CD es en realidad un programa. Cuando lo invocamos le pasamos como argumento la ruta del directorio al que queremos acceder. Esta ruta es una cadena de caracteres. CD busca dicha ruta y si la encuentra nos dará acceso, en caso contrario nos lanzará un error y se cerrará.

Ahora bien, si en vez de ejecutar un programa Java que está en un .class queremos ejecutar un programa que está en un .jar, el comando es

Código:
java –jar <nombreDelPrograma>


Como ven, primero le pasamos al programa java un argumento –jar que le indicará que abriremos un archivo jar, y luego le pasamos el nombre o la dirección del archivo. Entonces en este caso el programa java recibe dos argumentos en vez de uno.
Bien, nosotros podemos hacer algo similar con nuestros programas Java. Supongan que tenemos nuestro programa HolaMundo en el archivo HolaMundo.class dentro de U:\Java, para invocarlo por consola haríamos

Código:
java U:\Java\HolaMundo


Sin embargo, podemos agregar luego del nombre del programa los argumentos que quisiéramos pasarle como entrada, por ejemplo:

Código:
java U:\Java\HolaMundo Argumento1 Argumento2 Lala Lolo


Con eso, además de invocar al programa HolaMundo la JVM leerá cada arguemnto como un String y lo agregará al argumento args. En este ejemplo, la posición 0 de args contendrá la palabra Arguemnto1, la posición 1 Argumento2, la posición 2 Lala y la posición 3 Lolo.

He modificado el código del HolaMundo para que muestre los argumentos ingresados a la entrada:

Código:
  1. public class HolaMundo {
  2. public static void main(String[] args){
  3. System.out.println("\nLos argumentos ingresados son:\n\n");
  4. for(int i=0; i<args.length; i++)
  5. System.out.println(args[i]);
  6. }
  7. }


Lo único que hace este programa es recorrer el arreglo args imprimiendo cada posición en una línea de la salida estándar. Veamos un ejemplo de ejecución donde abro la consola, me posiciono en el directorio Java que es donde tengo mi programa HolaMundo en un archivo JAR y luego lo ejecuto pasándole argumentos:



Aquí les dejo el mismo for usado pero cambiado a for-each:

Código:
  1. for(String s:args)
  2. System.out.println(s);


Ahora sí, ya tenemos analizada por completo la firma del main y el por qué de cada cosa. En este ejemplo solo imprimimos los argumentos, pero ustedes bien podrían implementar un sistema que realmente tomara argumentos de entrada e hiciera algo con ellos.

NOTA: Si no se pasan argumentos de entrada o bien, el programa no se invoca por consola, el arreglo args será vacío.

============================================

En la próxima lección tendremos una introducción a interfaces gráficas sencillas con pequeños cuadros de diálogo.



Ultima edición por Kyshuo Ayame el Miércoles 08 May 2013 21:17; editado 1 vez
Volver arriba
Ver perfil del usuario Enviar mensaje privado
pirdy
Usuario Inquieto


Registrado: 11 Feb 2010
Mensajes: 137

Mensaje Publicado: Jueves 22 Nov 2012 01:28

Título del mensaje: Re: Lección 75: Distribución de aplicaciones - Línea de coma

Responder citando

Excelente profe.

¿Que nivel de programacion se adquiriria si se dominase ya estas lecciones?¿Seria suficiente para plantearse programar en un entorno profesional?me refiero como alguien que empieza obviamente.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 22 Nov 2012 02:51

Título del mensaje: Re: Lección 75: Distribución de aplicaciones - Línea de coma

Responder citando

Por supuesto que sí, obviamente aún nos falta camino por recorrer, pero es la idea.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
xRoki
Usuario Inquieto


Registrado: 22 Ago 2013
Mensajes: 71

Mensaje Publicado: Jueves 14 Nov 2013 01:05

Título del mensaje: Re: Lección 75: Distribución de aplicaciones - Línea de coma

Responder citando

ayuda porfavor no entiendo mi problema ... tengo arreglado el error de javac . pero cuando entro a cmd.exe ... pongo javac .. me dice acceso denegado .. no entiendo . ayudenme profavor

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 14 Nov 2013 04:15

Título del mensaje: Re: Lección 75: Distribución de aplicaciones - Línea de coma

Responder citando

Eso es porque no estás como administrador en tu sistema. ¿con qué usuario inicias Windows?

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Alfonso Lara
Usuario Iniciado


Registrado: 07 May 2019
Mensajes: 13

Mensaje Publicado: Viernes 24 May 2019 00:45

Título del mensaje: Lección 75: Distribución de aplicaciones - Línea de comandos

Responder citando

Excelente lección como de costumbre profesor Kyshuo.
Tengo la siguiente situación, cuando intento correr el código del HolaMundo desde consola me arroja un error :
Código:
No hay ningún atributo de manifiesto principal HolaMundo.jar

Cuando intento ejecutar desde el IDE resulta un mensaje similar:
Código:
no main class found

El código del HolaMundo lo intenté hacer como se plantea en la lección en lo referente al argumento tipo arreglo String llamado args, pero al ver el error le retiré el for each y simplemente lo dejé como sigue, pero el error persiste:
Código:
public class HolaMundo {
    public static void main (String [] args){
        System.out.println("hola mundo");
    }
}

Borré el proyecto e intenté varias veces, no sé qué estaré haciendo mal, los demás proyectos del curso corren normalmente.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Viernes 24 May 2019 01:42

Título del mensaje: Lección 75: Distribución de aplicaciones - Línea de comandos

Responder citando

No sé bien qué comando estás usando, pero deberías abrir la consola en la carpeta donde está tu clase compilada, y allí escribir:

Código:
  1. java HolaMundo

o mejor aun

Código:
  1. java HolaMundo.class

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Alfonso Lara
Usuario Iniciado


Registrado: 07 May 2019
Mensajes: 13

Mensaje Publicado: Viernes 24 May 2019 02:38

Título del mensaje: Lección 75: Distribución de aplicaciones - Línea de comandos

Responder citando

Me parece tan extraño, no sé qué hice mal, lo que intento hacer ahora mismo es crear el clásico HolaMundo e intentar correrlo desde el IDE y nada, se emite:
Código:
Error: no se ha encontrado o cargado la clase principal holamundo.HolaMundo
Java Result: 1

Y luego pruebo desde consola y logro compilar a partir del archivo .java, es decir, se genera el archivo .class en la carpeta que corresponde. Pero al momento de digitar el comando desde el directorio que corresponde:
Código:
Error: no se ha encontrado o cargado la clase principal HolaMundo

Intenté también permitiendo que Netbeans creara la clase principal y no resulta, es decir, me parece que el problema no se limita a la consola sino que desde el mismo Netbeans no corren los nuevos proyectos ...¿qué podrá ser?


Triste Triste

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Alfonso Lara
Usuario Iniciado


Registrado: 07 May 2019
Mensajes: 13

Mensaje Publicado: Viernes 24 May 2019 02:59

Título del mensaje: Lección 75: Distribución de aplicaciones - Línea de comandos

Responder citando

Solucionado, aunque no estoy seguro qué ocurría de repente todo volvió a la normalidad. El ejercicio finalmente lo pude hacer en normalidad.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Comprar una Tablet o Smarphone para probar apli...

Victor Carvajal Programación para dispositivos móviles 1 Jueves 20 Abr 2017 23:24 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Ir al final de la línea

rafaelh96 C, C#, Visual C++ 1 Sábado 02 Jul 2016 13:41 Ver último mensaje
El foro no contiene ningún mensaje nuevo

como leer linea por linea un richtextbox en vis...

WhiteSkull C, C#, Visual C++ 2 Jueves 17 Mar 2016 10:33 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Distribución de software

ikaros-san Temas legales 1 Sábado 13 Feb 2016 01:12 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,