2.7.16

Por cosas como estas es por lo que quiero irme de Blogspot


Muchos de los que me seguís ya conocéis mi pelea constante con Blogspot, algo que viene desde hace unos cuatro o cinco años.

Blogspot me gustaba mucho antes, durante la primera década del 2000 era una plataforma fiable, robusta pero, sobre todo, consistente. A diferencia de otras plataformas y CMSs, en donde cada actualización significaba tener que adaptarse a nuevas funciones y, en ocasiones, te estropeaba todo lo que tenías hecho (en unos blogs que llevábamos habíamos programado galerías propias, y de pronto y de la noche a la mañana Wordpress empezó a soportarlas y para usarlas tuvimos que rescribir todas las aplicaciones) Blogspot llevaba años manteniéndose fiel a su esencia, sin apenas cambios o con cambios muy pequeños.

Es verdad que algunos le achacaban que se había quedado obsoleta, y que tenía muchas limitaciones (por ejemplo, recuerdo que solamente podías subir cinco fotos), pero existían plugins o extensiones de navegador que paliaban buena parte de todas esas carencias.




Pero un día, de pronto, y tras llevar años sin tocarla, Google decidió modificarla por completo y cambió radicalmente toda la plataforma: forma de escribir los posts, de gestionar los gadgets, de colgar imágenes...

Lo peor es que eso lo hizo sin avisar, repentinamente. De un día para otro cambiaron todo su sistema de blogs sin decir nada. Eso nos obligó a todos los que ya teníamos un formato más o menos específico de escribir los posts y su diseño, a cambiar radicalmente y empezar de nuevo. Y a partir de ahí no pararon, se sucedieron cambios menores cada pocos meses que, aunque eran pequeños, afectaban enormemente al rendimiento y a la experiencia de usuario. Todo eso lo hacían -y lo siguen haciendo- sin avisar, sin decirte nada. Un día puedes entrar y ver tu blog "patas arriba" porque a alguien en Google le apeteció meter cualquier tontería en el código. Así, sin más.

Aun siendo nefasto, eso no es lo peor: lo peor es cuando cambian algo, están un par de días con ello, no les gusta (o no les funciona, o crea conflictos o vete a saber tú por qué razón) y vuelven atrás y "desactualizan la actualización".


Esto afecta en gran manera a todos los que usamos Blogger, porque todo lo que hacíamos (posts, imágenes, leyendas de imágenes, galerías...) deja de funcionar o funciona mal, y tenemos que cambiar la forma de escribir los posts.

Mi quebradero de cabeza con ellos (con esta gente de Blogspot) es tremendo, porque yo no uso su editor. Para redactar, maquetar, escribir y publicar posts, imágenes y galerías tengo escritas varias pequeñas aplicaciones que me permiten hacerlo más rápido (y mejor, y más cómodamente) que su sistema. El problema es que todas esas aplicaciones funcionan en base a los códigos que genera la plataforma, y si varían, tengo que reescribirlas de nuevo con la consiguiente molestia.


Lo último fue ayer. Estaba preparando unos posts para publicar en ZonaCasio Radio cuando me doy cuenta que las imágenes no quedan correctamente en el artículo. Yo siempre suelo publicar imágenes a 600px de tamaño (Blogspot solo permite hasta 400px, y si quieres que en tu post salgan mayores tienes que ir cambiándolas una por una, por eso uso una aplicación que lo hace por mí y es más cómodo que buscar imagen por imagen en el código fuente), y en el post aparecían pequeñas, a 400 o 320 px según los casos.

Creyendo que podría haberme equivocado de botón (tengo varias opciones de tamaños en mi programa) vuelvo a intentarlo y descubro que continúan de la misma forma, de manera que opto por extraer todo el código y revisar línea por línea. A continuación podéis ver la función que utilizo para llevar a cabo ese proceso (código Delphi/Lazarus):

Function cambiaT (texto,pror:string):string;
var
y:integer;
r,a:string;
tan,uno:boolean;
begin
r:='';
a:='';
tan:=false;
uno:=false;
for y:=1 to length(texto) do
begin
r:=texto[y];
if (r = 's') and (texto[y-1] = '/') then
begin
tan:=true;
end
else if (texto[y] = '/') then
tan:=false;
if (tan=true) and (uno=false) then
begin
a:=a + texto[y] + pror;
uno:=true;
end
else if (tan=false) then
a:= a + texto[y];
end;
Result:=a;
end;



¿Qué había ocurrido? resulta que ahora Blogger "lee cada imagen" en pequeño, y añade su tamaño en el código de imagen, algo que antes no hacían (antes usaban un identificador propio, "s" - de "size"- seguido por un número).

Como ese trozo de código no estaba antes, mi editor no lo filtraba ni lo detectaba. Hay otro problema, y es que Blogspot diferencia cuándo una imagen está personalizada (centrada, a la derecha...) añadiéndole la etiqueta "div", o cuándo no la quieres personalizar, en cuyo caso no tiene etiqueta "div". Además, como ya hacían antes, aunque tú subas una imagen ellos automáticamente la modifican de tamaño, poniendo varias imágenes más pequeñas (thumbnails), y una en tamaño grande (máximo 1600 px, Blogspot no permite tamaños mayores). Si quieres usarlas -como yo hago, utilizando una mediana para el artículo y una grande por si el usuario quiere hacer click en ella y abrir la imagen y verla aumentada- tendrás que gestionarlas independientemente. Ahora, además de eso, hay que jugar con los "s" (los mencionados "size") y con los tamaños width y height en código. Un galimatías.


Por supuesto, todos los programas que yo usaba (editor y gestor de galerías) se fueron al garete, porque ya no funcionan correctamente con esa actualización que en Blogspot pusieron ayer sin avisar.

Harto ya de tener que reescribir código, he decidido hacer otra cosa, y voy a quitar la sección de imágenes de mi editor de posts (hasta ahora podía añadir las imágenes dinámicamente en el editor, pero ya no será así). De esta manera cada vez que actualicen su gestión de imágenes modificaré mi programa de imágenes, y el editor de posts no se verá afectado.

Durante la tarde de ayer me dediqué a reescribir todo el código para que detectara esos tags nuevos pero, ya aprovechando, le incluí una función nueva, y es la de poder copiar (o cortar) el texto simplemente con poner el cursor en cualquier parte del trozo de código de la imagen y hacer click. Es una característica que llevo tiempo queriendo implementar, pero que nunca encontré las ganas de ponerme a ello. Y es que -no se por qué- arrastrar para seleccionar texto y luego copiarlo o cortarlo cada vez me desagrada más, y si eso puede hacerlo el programa por sí solo, ¿por qué no ahorrármelo yo?


Hay bastantes componentes que llevan esa característica (paragraph), mi problema es que la aplicación la escribo en Delphi/Lazarus (por comodidad, eficiencia y porque es mas ligera que en VB), y el objeto memo no tiene por defecto esa posibilidad. Además, quería que fuera en código lo más básico posible, prescindiendo de recursos externos para así poderla llevar a cualquier otra versión de Delphi/Lazarus que me apeteciera en un futuro.

Como es algo que he visto que hay gente que le interesa, y que no hay ningún ejemplo de su implementación en la Red, voy a poner aquí el trozo de código que usé para solucionarlo y de esta forma cuando alguien la busque podrá simplemente copiar y pegar (si dan con este blog...):

Line := Memo1.Perform(EM_LINEFROMCHAR, memo1.SelStart, 0) ;
memo2.lines.clear;

if (memo1.Lines[line] = '') then
showmessage('Nada que copiar')
else

begin
for h:=0 to memo1.lines.count do //Line do
begin
d:= memo1.Lines[line];
if (d = '') or (Line = 0) then //estamos en la primera línea o en un intro
break
else
Line:=Line-1;
end;
//en Line ahora tenemos la línea desde la que partir

if d = '' then Line:=Line+1;

d:= 'B';
listbox1.Clear;
while d <> 'A' do
begin
d:= memo1.Lines[line]; //aquí tenemos la línea
memo2.lines.add(d);
ListBox1.Items.Add(inttostr(Line));
line := line +1;
if (d = '') or (Line >= memo1.lines.count) then d:= 'A';
end; //while

//borrar líneas del memo
for h:=0 to listbox1.Items.count -1 do
begin
memo1.Lines.Delete(strtoint(listbox1.Items[0]));
end;

memo2.Selectall;
memo2.CutToClipboard;
memo1.SetFocus;


He recurrido a un segundo objeto tMemo por comodidad, se puede hacer también seleccionando y cortando la parte del texto (con select, añadiendo cada extensión de los carácteres línea por línea), pero siempre me resulta -no se por qué- más agradable usar un segundo componente invisible. Quizá sea porque da mucho más juego y, en depuración, puedes ver cómo va haciendo lo que pides.

Luego procedo a borrar línea por línea del editor original, que simula el proceso de cortar. Para llevarlo a cabo uso un tlist al que llevo el número de líneas. El número de cada línea es indiferente, lo interesante es saber el número total de ellas y, sobre todo, la primera, porque en realidad es esa la que vamos a eliminar una y otra vez (de ahí el Items[0]), porque, como el programa no las elimina en bloque, si nos pusiéramos a eliminar la línea 10, por ejemplo, y la línea 11 a continuación, en realidad estaríamos eliminando la línea 12 original, y así con el resto, dando como resultado un caos (y un fallo del programa si intentásemos eliminar una línea del final inexistente).

Espero que Google deje ya de jugar y nos permita, al menos por un tiempo, a todos los que trabajamos con sus blogs tener un periodo de calma sin contratiempos ni molestas actualizaciones. Aunque mucho me temo que no será éste el último susto que nos llevemos de ellos.


| Redacción: Bianamaran.blogspot.com

5 comentarios :

  1. Que bueno que le des a Lazarus también. Siempre he odiado Pascal y Object Pascal como lenguaje, pero es verdad que como IDE, primero Turbo Pascal, luego Delphi, y ahora Lazarus/Deplhi, son una maravilla. Desarrollo rápido, y código nativo y eficiente.

    De lo de Blogspot, pues ya lo sabes. Estás a expensas de lo que el dueño del servicio considere. Pero tampoco pienses que mirar a otro CMS es la panacea, por defecto Wordpress aplica automáticamente actualizaciones, y en versiones mayores, cuando se deja obsoleto algo, puede que haya problemas. Vamos que a mi me ocurre de tanto en tanto.

    Incluso si el hosting es propio, bueno, mejor dicho compartido como es mi caso, llegará un momento que te actualizarán PHP, o MySQL, y algo deje de funcionar.

    Supongo que en un sector donde todo cambia tan rápido, o se quiere que cambie tan rápido es inevitable. Reconozco que PHP 7, rompe cosas, pero es una virguería. En cambio, las modificaciones a Blogspot, pues con decirte que con Opera 12 es inmanejable el administrador te digo todo. Y eso que iba perfectamente, y bien rápido hace 2 años. Pues mira, ahora hace lo mismo, pero mucho más lento.

    ResponderEliminar
    Respuestas
    1. Gracias Guti. Aunque supongo que no te gustará mucho porque para un escritor en C tan elegante como tú ver referenciar a tanta variable indiferentemente en minúscula o mayúscula debe darle dolor :D

      Sí, eso es lo malo, que lo actualizan pero en el fondo no aporta nada.

      Eliminar
  2. Muchas gracias Bia Namaran. El ser elegante o no, depende más del programador en cuestión que del propio lenguaje. Sabes que VB es muy criticado como poco estructurado, pero con práctica, y cuidado, se puede programar de manera tan buena como cualquier otro lenguaje.

    Lazarus me gusta, de hecho comencé con él antes de que saliera la 1.0, y antes usé algo de Delphi, y mucho antes Turbo Pascal/Borland Pascal. Son entornos que me gustan mucho, estables, fáciles de usar, y con una velocidad de compilación asombrosa (Lazarus no tanto). Pero Object Pascal, es un lenguaje con el que nunca he podido. Aquí lo explicaba con más detalle: http://www.javiergutierrezchamorro.com/mi-relacion-con-pascal/1948

    Pero vamos, que he usado Pascal cuando ha hecho falta, primero con BP/TP porque eran magníficos insertando ensamblador; luego Delphi porque ofrecía componentes Windows que C++ Builder, abandonado en aquel momento no tenía; y finalmente Lazarus, cuando soportaba completamente x64, cosa que a Delphi le llevó 3 o 4 años más; y 6 o 7 años más de lo anunciado.

    Si tienes curiosidad, aquí tienes lo último que hice en 2012: http://nikkhokkho.sourceforge.net/static.php?page=Lamark

    ResponderEliminar
  3. Sí, lo de VB tienes mucha razón, pero cuando alguien es caótico de por sí (como es mi caso) te invita a ser más caótico aún y acabas llamando a las variables string pepita, y a las integer "pepon", sin ningún tipo de lógica ni eficiencia. Hubo un tiempo en que me intentaba fijar en esas cosas, pero como el lenguaje te lo permite, pues uno corre el riesgo de acabar malacostumbrándose. En todo caso es una batalla que asumo y ya doy por perdida, porque ya llevo muchos años haciéndolo así. Eso sí, cuando tengo que realizar algún tipo de mantenimiento de aplicaciones, sufro y me pregunto el por qué no programaré más elegantemente :D

    Lazarus respecto a Delphi, como bien señalas, es mucho más lento al compilar, pero es cierto que al menos es de agradecer que sigan con un proyecto así. A mí Lazarus también me encanta, es al que recurro (o a Delphi) cuando no quiero hacer las cosas en VB.

    Menudo nivelazo de aplicaciones haces, he visto el código del Lamark en Lazarus y respecto a lo que yo lo haría es como la noche y el día :D arrays, sockets, buffers, ensamblador... todo bien estructurado y sin variables tipo "marianaLapelirroja" o "bertaLaguapa", si vieras mis códigos te morirías de risa. Pero por otro lado, y dado que programar lo hago por simple entretenimiento, VB me permite seguir disfrutando con ello. Honestamente creo que ningún otro lenguaje me haría más feliz, me resultaría soporífero y me aburriría mucho :(

    Eso sí, cuando leo código como el que escribes tú me encanta, es como ver un buen cuadro de un gran artista.

    ResponderEliminar
  4. Pues gracias de verdad por lo del código de Lamark, porque sin falsa modestia, es de los peores que tengo.

    La historia es que estaba programado en C++ Builder, simplemente como un entretenimiento para poder comparar el rendimiento de diferentes partes de un PC, y en homenaje al Landmark Speed Test, y los benchmarks clásicos que siempre me gustaron.

    Lo empecé en 2006 con mi Athlon a 1400 Mhz, pero C++ Builder 2007 (con el que lo comencé), estaba obsoleto, y el 2009 no añadió nada nuevo y luego el 2010.

    En 2010, lo reescribí todo en Visual C++, la idea era tener binarios de 64 bits, donde hay que explotar cada bit disponible como son los benchmarks. Al final fue muy laborioso, y mi desconocimiento de las MFC (hacía que no las tocaba desde 2000 o así), tenía lagunas y errores.

    En 2011 o así, con Lazarus creo 0.8, lo porté entero en Pascal. Pensaba que me costaría, porque llevaba quizás 10 años sin tocar Pascal en serio. Pero la VCL no se olvida, de hecho es casi igual en Delphi, que Lazarus que C++ Builder. Y el ensamblador, es ensamblador y poco ha cambiado.

    Con él, probé en serio Lazarus, aprendí ensamblador moderno (SSE, SSE2, x64, ...). En fin, que fue muy divertido.

    ResponderEliminar

El Imperio