Mostrando entradas con la etiqueta Tecnificados. Mostrar todas las entradas
Mostrando entradas con la etiqueta Tecnificados. Mostrar todas las entradas

miércoles, 21 de abril de 2021

Procesando ficheros grandes en JAVA


Llevamos unas semanas con varias filtraciones de datos, hace unas semanas hubo una de Facebook, y hoy hemos tenido otra con datos de una empresa de telefonía...

Cuando nos enteramos de estas cosas, nos gustaría saber si se han filtrado nuestros datos, pero para eso hay que tener los datos (algo que a veces es difícil de encontrar) y después tener las herramientas para abrir esos ficheros.

En los dos casos que he comentado, los ficheros eran texto plano, en formato CSV.

El primero ocupaba 800 MB y el segundo 5,36 GB

Yo no he conseguido abrir ninguno con las herramientas habituales.

Así que he escrito un pequeño programa que lee línea a línea cualquier fichero, busca en cada línea la cadena que nos interese, y las coincidencias que encuentra las escribe en otro fichero.

Podéis acceder a ese desarrollo desde aquí: https://github.com/tecnificados/bigFileOpps

Espero que os sea útil.

Nos vemos pronto.

Muchas gracias a  Hugo y a Valandil por su ayuda consiguiendo los datos.




domingo, 18 de abril de 2021

Spring Boot: un CRUD hecho y derecho

 


Este es el quinto (y último) artículo de la serie sobre Spring Boot que comenzamos el mes de Febrero. Estos son los anteriores:

El proyecto con el que estamos trabajando esta en GitHub y esta es su URL:  https://github.com/tecnificados/boot

Hoy vamos a coger todo lo que hemos aprendido y transformar nuestras diferentes pruebas en un CRUD de Incidencias. 

Antes de nada, ¿qué es eso? CRUD es un acrónimo de CREATE, READ, UPDATE Y DELETE. Cuando alguien nos habla de este término, a lo que se refiere es a un proyecto que permite realizar estas operaciones sobre una o más entidades.

En los diferentes commits que he hecho estos dos días he ido añadiendo operación por operación los diversos cambios en un nuevo Controlador (IncidenciasController), y añadiendo las diferentes JSPs:


Creo que se pueden seguir muy fácilmente, por lo que esta vez no voy a comentar nada del código utilizado.

En el último commit, he eliminado todas las páginas y código que ya no se utilizan, son las que creamos en las primeras entregas para repasar conceptos básicos.

Aunque seguiremos basándonos en este proyecto en futuros artículos, no realizaremos cambios sobre él. Las modificaciones serán a través de forks, así siempre tendremos el ejemplo de un CRUD básico funcionando.




Si tenéis cualquier duda o problemas podéis contactar conmigo por el correo de contacto habitual: tecnifica2@gmail.com

Nos vemos pronto.

sábado, 13 de marzo de 2021

Spring Boot: Trabajando con bases de datos

Este es el tercer artículo de la serie sobre Spring Boot que comenzamos hace el mes pasado, los anteriores los tienes aquí:
El proyecto con el que estamos trabajando esta en GitHub en la siguiente URL:  https://github.com/tecnificados/boot

Hoy vamos a empezar a trabajar con bases de datos, la configuración ya la establecimos en el anterior post, así que hoy vamos empezar a utilizar esa conexión.

Los cambios que vamos a comentar se corresponden con los commits del 12 de Marzo de 2021:



Clases de acceso a datos, modelo, servicio y script de BBDD (Commit 92a6848)

El objetivo de hoy es crear un tabla y trabajar con ella (insertando, borrando,...), así que lo primero que tenemos que hacer es crear esa tabla a través de un script, lo tenéis en el fichero 'incidencia.sql' en la carpeta 'scripts':

CREATE TABLE incidencia ( 
 id int(11) NOT NULL, 
 titulo varchar(255) DEFAULT NULL, 
 descripcion varchar(2000) DEFAULT NULL, 
 estado int(20) NOT NULL, 
 autor varchar(50) NOT NULL ); 

ALTER TABLE incidencia ADD PRIMARY KEY (id);

Ahora vamos a crear las clases necesarias para trabajar con esa tabla, gracias al framework que utilizamos la cantidad de código que utilizamos es muy pequeña, pero no os asustéis que funciona. Estas son las clases que necesitamos:


Empezamos por el modelo, la clase 'Incidencia.java' es la clase que se corresponde con nuestra tabla. A nivel de código no hay mucho misterio, tiene los atributos que se corresponden con nuestras columnas, y los métodos get y set, un bean de los de toda la vida, pero con anotaciones:

@Entity
public class Incidencia {

@Id
private Long id;

@Column
private String titulo;

@Column
private String descripcion;

@Column
private Integer estado;

@Column
private String autor;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getTitulo() {
return titulo;
}

public void setTitulo(String titulo) {
this.titulo = titulo;
}

public String getDescripcion() {
return descripcion;
}

public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}

public Integer getEstado() {
return estado;
}

public void setEstado(Integer estado) {
this.estado = estado;
}

public String getAutor() {
return autor;
}

public void setAutor(String autor) {
this.autor = autor;
}

}


Ahora vamos a ver la clase DAO (Data Access Object), esta es la clase que encarga de realizar las comunicaciones directamente con la Base de Datos.

public interface IncidenciaDAO extends CrudRepository<Incidencia, Long> {

@Query(value = "SELECT coalesce(max(id), 0) FROM Incidencia")
Long getMaxTransactionId();

}

Como podéis ver no tiene casi código ya que a través de la clase que hereda ya obtiene las operaciones básicas.

He añadido el método "getMaxTransactionId()" que se corresponde con la consulta que se puede leer. Lo que hace es sacar el id más alto de la tabla, en caso de no existir devuelve 0.

Ahora tenemos que ver las clases que están dentro del paquete "service". Estas clases son las encargadas de trabajar con las DAO. La verdad es que no tienen mucho que explicar, os recomiendo que las veáis siguiendo este orden:
  1. GenericService.java: interfaz genérica (que nos sirve para cualquier tabla).
  2. GenericServiceImp.java: implementación de la anterior.
  3. IncidenciaService.java: interfaz para Incidencia (aquí nos definimos las particularidades de nuestra clase).
  4. IncidenciaServiceImpl.java: implementación.
Ya tenemos las clases listas para operar con nuestra tabla.

Configuración del pool de conexiones (Commit 1b9d186)

Este es un cambio rápido: vamos a activar el pool de conexiones. 

Necesitamos configurarlo para que haya más de una conexión disponible, de manera que si tenemos más de un usuario, haya conexiones para todos y no se ralentice nuestra aplicación en caso de llevar parada mucho tiempo y que de repente aparezcan varios usuarios a la vez.

Se configura muy fácilmente añadiendo estas líneas en nuestro 'application.properties':

#Configuración del Pool de conexiones
spring.datasource.initial-size=10
spring.datasource.max-active=20
spring.datasource.max-idle=5
spring.datasource.min-idle=1

Cambios en el controlador que utilizan la BBDD (Commit e55a9aa)

En este cambio lo que hemos hecho es cambiar nuestro controlador inicial con nuevos métodos y modificando el inicial para trabajar con BBDD.

El cambio fundamental son estas líneas:

@Autowired
private IncidenciaService incidenciaService;

Gracias a ellas se inyecta el servicio que nos permite trabajar con nuestra tabla.

El método inicial ahora se llama index(), y hace una llamada al listado de incidencias, pasando el resultado al modelo:

        @RequestMapping(DEFAULT)
public ModelAndView  index() {

List<Incidencia> list = incidenciaService.getAll();
ModelAndView model = new ModelAndView();
model.addObject("list", list);
model.setViewName("index");

return model;
}

DEFAULT es una constante que se corresponde con "/" que es la página por defecto: localhost:8080

He añadido el método add() que añade una incidencia (siempre la misma) cada vez que se le invoca:

        @RequestMapping(ADD)
@ResponseBody
public String  add() {
Long id=incidenciaService.maxId()+1;
Incidencia incidencia = new Incidencia();
incidencia.setId(id);
incidencia.setAutor("Juan Carlos");
incidencia.setTitulo("Incidencia "+incidencia.getId());
incidencia.setDescripcion("La aplicación no arranca");
incidencia.setEstado(0);
incidenciaService.save(incidencia);

return "added";
}
ADD es una constante que se corresponde con "/add": localhost:8080/add

Con @ResponseBody indicamos que lo que se devuelve y debe aparecer directamente en la salida html.

El método empty() lo que hace es borrar todas incidencias creadas, siguiendo la misma lógica.

Para que todo funcione hay que añadir las nuevas operaciones en nuestro 'WebSecurityConfig' e indicarle que no requieren autenticación:

         .antMatchers(StartController.DEFAULT,
StartController.ADD,
StartController.EMPTY,
"/login",
/resources/**").permitAll()
.anyRequest().authenticated()


Cambios en la página inicial para mostrar la información de Incidencias (Commit 8a10cf3)

En este commit solo hemos modificado la JSP para que en caso de existir incidencias en la tabla las muestre en la página inicial, en caso contrario nos indicará que no hay incidencias:




Ahora con logs (Commit f342578)

Y para terminar, he añadido un sistema de log en la aplicación, realmente ya estaba, solo lo he añadido como atributo estático en el controlador:

    Logger logger = LoggerFactory.getLogger(StartController.class);

Y un fichero de configuración (logback-spring.xml) para elegir, si consola, fichero o ambos. 

En este punto ya tenemos nuestra aplicación trabajando con BBDD, ahora lo ideal sería generar un CRUD con diferentes pantallas y securizando el acceso a través de una página de login. Veremos como hacerlo próximamente.

Nos vemos pronto.

sábado, 27 de febrero de 2021

Spring Boot: Página inicial con Bootstrap

 

Este es el segundo artículo de la serie sobre Spring Boot que comenzamos hace dos semanas, si quieres ver el primero puedes acceder pulsando aquí.

En el primer artículo vimos cómo descargar nuestro proyecto configurado para nuestros intereses y listo para ser importado en nuestro IDE (nosotros usaremos Eclipse).

Lo primero que vamos a hacer es importar el proyecto:

  1. File -> Import
  2. Existing Maven Projects
  3. Seleccionamos el fichero pom.xml en la carpeta donde lo hemos descomprimido y esperamos unos segundos
Cuando acabe la importación, esta es la estructura que nos aparecerá:



Con Spring Boot no necesitamos configurar el servidor, ya se encarga él de facilitarnos la vida. Lo único que tenemos que hacer es arrancar la clase BootApplication.java, que se encargará de arrancar Tomcat y dejar nuestra aplicación funcionando en el puerto 8080. 

Y si todo fuera bien, podríamos acceder a través de la URL: http://localhost:8080/

Pero ahora mismo tenemos un error de conexión con base de datos que nos impide que la aplicación arranque.

Vamos a empezar a hacer unas cuantas modificaciones para que todo empiece a funcionar.

Para poder seguir todos los cambios he creado este repositorio en Githubhttps://github.com/tecnificados/boot 

Ahora mismo tiene los siguientes commits:


Los tres primeros commits son la creación del repositorio y la subida del código que descargamos de https://start.spring.io/

El cuarto commit es una corrección para que no nos dé problemas la configuración con la base de datos, si no añadimos estas líneas en el pom.xml, nuestro desarrollo será incapaz de conectarse con la base de datos. 

 <plugin> 

 <groupId>org.apache.maven.plugins</groupId> 

 <artifactId>maven-resources-plugin</artifactId>

 <version>3.1.0</version>

 </plugin>

Los dos últimos commits son los que quiero revisar con vosotros, ya que son los que nos van permitir hacer que la aplicación arranque y trabajar con JSPs, JSTL y añadir Bootstrap a través de sus recursos (css y js).

Cambios para poder trabajar con JSPs (Commit 757e5f2)

Lo primero que vamos a hacer es arreglar el problema con la base de datos. Debemos configurarla. Vamos a utilizar MySQL. Puedes instalarlo directamente, o utilizar la máquina virtual que subimos a Mega hace unas semanas (aquí el artículo). 

No hace falta tener ninguna tabla, simplemente que el servicio esté funcionando.

Vamos a editar el fichero application.properties y dejarlo con la configuración de conexión a BBDD:

#nivel de log en la aplicación
logging.level.root=info

#Configuración de Base de Datos
 
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 
#Url donde está el servicio de tu mysql y el nombre de la base de datos
spring.datasource.url=jdbc:mysql://localhost:3306/boot_demo?useSSL=false&serverTimezone=Europe/Madrid
 
#Usuario y contrasena para tu base de datos descrita en la línea anterior
spring.datasource.username=boot_demo
spring.datasource.password=boot_demo
 
#[opcional]Imprime en tu consola todo el SQL.
spring.jpa.show-sql = true

Si todo está bien ya podremos arrancar nuestro proyecto con la clase BootApplication.java

Y al acceder a través de http://localhost:8080/ veremos lo siguiente:


¿Qué es esto? Spring Security en nuestra aplicación, todo va bien.

Apagamos y vamos a decirle a Spring Security que de momento no proteja algunas páginas.

Para eso vamos a crear la clase WebSecurityConfig.java y añadiremos el siguiente contenido:

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
    .authorizeRequests()
.antMatchers("/", "/login", "/resources/**").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
    .loginPage("/login")
    .permitAll()
    .and()
    .logout()
    .permitAll();
}
}

Con esta clase entre otras cosas configuramos el acceso libre a las rutas:
  1. /: la pagina inicial
  2. /resources/**: ruta donde estarán nuestros recursos estáticos
  3. /login: nuestra página de acceso

En el fichero application.properties añadiremos estas líneas:

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

Así se configura la ruta a nuestras JSPs.

Ahora vamos a crear un controlador (StartController.java), que será el encargado de capturar las peticiones a la página inicial.

@Controller
public class StartController {
 
    @RequestMapping("/")
    public String mensaje() {
         
        return "index";
    }
}

Lo único que le decimos es que capture las peticiones a la página por defecto y las mande a la JSP index.jsp, que va a tener el siguiente contenido: 

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Hola</title>
</head>
<body>
Hola con Spring Boot
</body>
</html> 

Y para acabar este punto vamos a necesitar añadir la dependencia que permite ejecutar JSPs en nuestro fichero pom.xml:

<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>


Si ahora arrancamos de nuevo y accedemos a nuestro http://localhost:8080/ ahora deberíamos ver un saludo como este:

Es un poco simple, pero es un comienzo.

Cambios para desarrollar con recursos. Bootstrap añadido (Commit 37cfa22)

Este commit es muy importante, ya que vamos a crear la clase de configuración del proyecto (MvcConfig), donde vamos a poder ir añadiendo 'piezas' según las vayamos necesitando. Y la primera pieza a añadir es decirle a Spring que nos permita servir recursos estáticos como CSS y ficheros JS.

Para empezar vamos a ir por esos recursos, nos vamos a la web oficial de Bootstrap y nos descargamos la versión que nos interese (4.6 por ejemplo): https://getbootstrap.com/docs/4.6/getting-started/download/

Esto nos descargará un zip, vamos a descomprimir su contenido en la carpeta:  "src\main\webapp\resources"

Ahora ya tenemos que ya tenemos los recursos vamos a decirle a Spring dónde están y que nos permita acceder a ellos. Para esto creamos la clase MvcConfig.java


@Configuration
@EnableWebMvc
public class MvcConfig implements WebMvcConfigurer {
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
}

@Bean
public InternalResourceViewResolver viewResolver() {
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setViewClass(JstlView.class);
viewResolver.setPrefix("/WEB-INF/views/");
viewResolver.setSuffix(".jsp");
return viewResolver;
}
}

En el método addResourceHandlers configuramos dónde están nuestros recursos y con InternalResourceViewResolver configuramos dónde están nuestras JSPs. Esto último lo habíamos escrito en las primeras líneas del application.properties, como ahora debe estar aquí, lo borramos de ese fichero.

Ahora vamos a añadir dos dependencias nuevas a nuestro fichero pom.xml:


<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>jakarta.servlet.jsp.jstl</artifactId>
<version>1.2.6</version>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>

La primera es para poder usar las etiquetas JSTL en nuestras JSPs (los recursos los añadiremos con c:url) y la segunda es para que si hacemos modificaciones en nuestras páginas, Spring detecte los cambios sin tener que reiniciar.

Y para terminar vamos a modificar nuestra página de inicio para añadir acceso a los recursos que necesitamos y darle un formato un poco más llamativo.

Aquí os dejo un par de ejemplos para que veáis cómo se insertan recursos estáticos:


<script src="<c:url value="/resources/js/vendor/jquery.slim.min.js"/>"></script>

<link rel="stylesheet" href="<c:url value="/resources/css/bootstrap.min.css"/>" >


La página inicial la he modificado basándome en el ejemplo Jumbotron de Bootstrap

De modo que ahora nuestra página de inicio, tiene un aspecto bastante diferente del anterior:


En este punto ya tenemos lista nuestra aplicación para interactuar con nuestra base de datos y poder aplicar seguridad a diferentes páginas. Y lo iremos viendo poco a poco en los siguientes artículos de la serie.

Nos vemos pronto.

domingo, 4 de octubre de 2020

Java 15 ya está aquí

 


Hace unos días que se ha liberado la versión 15 de nuestro lenguaje de programación favorito, y ya podemos probarla y actualizarnos a través de la versión OPENJDK.

Se puede consultar el estado y las novedades que contiene en la URL:  https://openjdk.java.net/projects/jdk/15


Y para descargarla podemos ir al siguiente enlace: https://jdk.java.net/15/

Para actualizarnos (en Windows), sólo tenemos que descargarnos el zip, descomprimirlo y actualizar nuestras variables de entorno:

  • Yo lo he descomprimido en C:\java\OpenJDK15

  • Y he actualizado las variables de sistema "JAVA_HOME":

  • Y "Path":

Para verificarlo, solo tenemos que lanzar un "java -versión" en nuestra consola ("cmd"):


Con esto, ya estamos listos para utilizar las mejoras que trae (tengo muchas ganas de probar los bloques de texto).

Para acabar he hecho un pequeño proyecto de consola para consumir URLs a través del verbo HEAD, con esto podremos controlar de manera rápida si esa URL existe, sin tener que consumirla y gastar recursos (nuestros y del servidor).

Podéis ver el pequeño proyecto en la siguiente URL: https://github.com/tecnificados/urlChecker

Lo iremos evolucionando en los próximos POSTS.

martes, 18 de septiembre de 2018

Certificados SSL gratis para tod@s


Hace ya más de dos años aparecieron estos certificados que nos permiten de manera gratuita, aplicar el protocolo SSL a nuestros dominios y subdominios (ya podemos navegar vía https). 

Esto nos viene muy bien ya que ahora que todos los navegadores más comunes, catalogan las páginas sin https como no seguras.

Estos certificados vienen de un proyecto financiado por la organización EFF (Electronic Frontier Foundation) y la Fundación Linux .

Su objetivo es mejorar la seguridad de la web y ya de paso, permitir que cualquier persona pueda certificar su dominio, sin tener que desembolsar nada de dinero.

Todos los navegadores ya vienen de serie con sus CEAs así que no hay que andar peleándose con los almacenes de certificados del sistema operativo, o de cada navegador.

Si necesitáis más información podéis acceder a su web: https://letsencrypt.org/

Es muy fácil solicitar el certificado que necesitemos y renovarlo automaticamente. Además gracias a la comunidad (que se ha volcado con el proyecto), hay muchas utilidades para los diversos servidores: Tomcat, Apache, IIS,...

Y para más confianza, las grandes empresas como Google ya lo están utilizando, e incluso impulsando el proyecto.

Desde Mayo de este año incluso ya se pueden solicitar certificados de tipo wildcart (comodín, ejemplo: *.tecnificados.com).




sábado, 15 de septiembre de 2018

Curso 2018 - 2019: declaración de intenciones



Ya estamos en septiembre y toca plantearse que vamos a hacer este año en nuestro blog.

Todo el equipo ha estado hablando y de momento nos vamos a proponer un par de metas sencillas, que luego seguro que las iremos complicando.

Meta 1: crear un repositorio en Github e ir publicando todo lo que vayamos haciendo y algunas cosillas que hicimos el curso pasado para Conquista Iberia

Meta 2: ir construyendo poco a poco una aplicación web comentando los pasos que seguiremos, e ir viendo todos los avances a través de commits en Github

Cosas que se nos han quedado en el tintero:

  • aplicación móvil sencilla que os comente hace un par de artículos: no ha podido ser, se me ha complicado el verano, así que la dejo aparcada.
  • evolución de Conquista Iberia: imposible de momento, tendríamos que tener un hackaton de una semana para poder pulir el juego tal y como esta ahora mismo.
  • liberar el código de Conquista Iberia: la verdad es que no gustaría hacerlo, pero sin darle una vuelta para todo este bien documentado y estabilizado no.
Y de momento poco más, en breve tendréis más noticias nuestras.

Un saludo,

El equipo de Tecnificados

PD: faltan 8 meses para Vengadores 4

miércoles, 15 de agosto de 2018

Pausa



Hace ya unas semana que ha terminado el primer torneo de Conquista Iberia.

De momento, vamos a ponernos en pausa durante lo que queda de Agosto.

En breve volveréis a tener noticias nuestras.


sábado, 14 de julio de 2018

Aplicaciones híbridas: PhoneGap


Uno de los temas que tengo pendiente este año (tengo que repasar mi lista, pero creo que no me quedan más) es publicar una aplicación en "Google Play Store".

Pero cada vez que tengo que pensar en instalar el entorno de desarrollo de Android se me quitan las ganas.

Así que he pensado en intentar crear una aplicación híbrida, en lugar de nativa.

Y después de mirar un poco, he decidido utilizar PhoneGap.

Puedo desarrollar aplicaciones móviles utilizando HTML5 y no me limito a una sola plataforma.

Además he encontrado un curso "ligerito" en Miriada y en mis tiempos libres de Julio y Agosto voy a ir haciéndolo poco a poco.


De momento estoy pensando en hacer una primera aplicación que sea un juego clásico, aunque tampoco descarto hacer un pequeño cliente para Conquista Iberia.

lunes, 2 de julio de 2018

Conquista Iberia: mañana salimos

Mañana es el gran día, publicaremos "Conquista Iberia", que es la nueva versión de "Conquista Castilla y León".

Hemos añadido las mejoras que vistéis en la beta de hace unas semanas, y siguendo vuestros consejos hemos corregido algunas incidencias y programado nuevas características.

Os enumero todos los cambios desde "Conquista Castilla y León":
  • Nuevos territorios añadidos: todos los municipios de la península ibérica (España y Portugal)
  • Todas las tablas ahora se pueden ordenar por las distintas columnas
  • Territorios libres y ocupados ahora se cargan al entrar
  • Defensas de territorios libres calculados proporcionalmente a la población. ¿Cómo explicamos esto? Con un ejemplo: si una población tiene menos de 1000 habitantes, tiene unos defensores entre 2 y 5. Para más de 1000, se hace una regla de 3 para calcular el máximo y el mínimo. 
  • Las defensas de los territorios libres, ahora aparecen al lado de su población. 
  • Invita a tus amig@s: ahora puedes invitar a tus amigos con una URL, si se da de alta recibirás 20 tropas adicionales y tu colega 10 más.
  • Nuevos filtros en defensa y ataque. La idea es hacer más fácil la gestión cuando hay más municipios.
 Y ahora voy a contestar a unas preguntas que me soléis hacer:

  • ¿Vas a cobrar por el juego? Toda la motivación para hacer este juego es un reto personal. Ahora mismo, no me cuesta mucho dinero. Cuando suba el precio (a partir de Enero), ya veremos.
  • ¿Cómo lo financias? De mi propio bolsillo, no hay ninguna empresa detrás del juego.
  • ¿Cuánto te cuesta? Este año el servidor sale gratis gracias a la política de Amazon Web Services, sólo estoy pagando el dominio que son unos 30€ (dominio + anonimato). El año que viene el dominio creo que sube a 50€ y el servidor unos 200€.
  • ¿Hasta cuándo lo vas dejar? Si hay jugadores que quieran seguir jugando, lo dejaré funcionando, al menos hasta que llegue la subida de precio.
  • ¿Te puedo pagar por jugar? Ahora mismo no, pero me lo apunto por si quisieras pagar por alguna función premium.
  • ¿De dónde sacas la imagenes que utilizas? todas las imágenes que uso las menciono en la página de información del juego (en la portada pinchar en la "i" de la izquierda), pero la mayoría son de https://focaclipart.wordpress.com/.
  • ¿Puedes montarlo en privado para un grupo reducido de amigos/pequeña empresa? Claro, pero tendríamos que ver cómo pagar los gastos del servidor exclusivo, y el tiempo de gestión. Piensa que lo más caro es el servidor y sale por menos de 20€ al mes.
  • ¿Cuántos desarrolladores tiene tu equipo? Ahora mismo el principal desarrollador soy yo, también está Stanz que me ayuda cuando no esta ocupado, y la persona anónima que está detras de @tecnificados, que no es programador, pero ayuda en todo lo que puede. 
  • ¿Algún otro proyecto? Sí, tengo otro juego en mente. El problema como siempre es el tiempo. Si consigo más apoyo me lo plantaré a partir de septiembre.
Y nada más, cualquier cosilla ya sabéis que estoy disponible en tecnifica2@gmail.com.

Nos vemos mañana en "Conquista Iberia".

lunes, 25 de junio de 2018

Conquista Iberia: necesitamos unos días más






Acabamos de tomar la decisión de postponer la salida de "Conquista Ibería".

Estamos mejorando un par de pantallas, y casí hemos tenido que rehacer la lógica desde cero...

Esto nos ha llevado más tiempo del que pensabamos y preferimos no arriesgarnos.

Os seguiremos informando.

Ya queda menos!!!!

viernes, 22 de junio de 2018

Conquista Iberia: beta cerrada

El fin de semana pasado estuvimos trabajando en "Conquista Iberia", publicamos su beta el domingo por la noche, y esta semana la hemos estado probando.

Salvo unos problemitas que ya tenemos controlados, ha sido un éxito.

Este fin de semana añadiremos unas mejoras y el martes 26 saldremos con el primer torneo oficial.

Muchas gracias a los betatesters y enhorabuena a Esther que arrasa hasta en las betas.