En enero de 2024, tras ver cómo la enésima inmobiliaria le cerraba la puerta tras enterarse de su origen marroquí, Hamid pidió a un compañero de trabajo que le echase un cable. Su amigo (de nombre español) llamó a la misma agencia preguntando por un piso de Mataró por el que poco antes se había interesado Hamid. No tuvo problema.
etiquetas: inmobiliaria, racismo, alquiler
» noticia original (www.xataka.com)
El 4 de octubre, Marimar Martínez, asistente de maestra en una escuela Montessori, conducía por Chicago cuando vio a agentes federales de inmigración patrullando. Había empezado a tocar la bocina para advertir a sus vecinos de su presencia cuando chocó contra un vehículo de la Patrulla Fronteriza. Momentos después, el agente en el vehículo, Charles Exum, disparó varias veces contra el coche de Martínez, impactándola repetidamente. (Más tarde, Exum presumiría ante sus colegas de que había "disparado cinco balas y que ella tenía siete agujeros").
etiquetas: ee.uu., jamelle bouie, ice, nyt
» noticia original (www.nytimes.com)
Hay letras de canciones que me costaba descifrar hasta que un día supe su sentido real, o que parecían claras hasta que un vídeo o una imagen me dieron la sorpresa.
Realmente no es importante buscar significados, porque es raro que cambien la emoción que la canción despertó en ti.
Tres ejemplos:
Sauvignon Blanc, de Rosalía
Mi favorita de LUX junto con Sexo, Violencia y Llantas. En la primera escucha, Sauvignon Blanc parece una clásica canción de amor. Pero en el vídeo, que salió esta semana, se adivina que va dirigida a Dios o al menos a una espiritualidad que trae paz y plenitud.
Boig Per Tu, de Sau
Esta balada que me persigue es una canción de amor con la particularidad de que a quien canta es a la luna. Metafóricamente, tal vez, pero las imágenes cobran sentido cuando las vemos desde ese prisma.
Ay, Amor, de Valeria Castro
La letra me resultaba críptica hasta que supe que trataba sobre la experiencia de los migrantes y el amor que merecen como cualquier ser humano.
On Monday, a pull request executed by an AI agent to the popular Python charting library matplotlib turned into a 45-comment debate about whether AI-generated code belongs in open source projects. What made that debate all the more unusual was that the AI agent itself took part, going so far as to publish a blog post calling out the original maintainer by name and reputation.
To be clear, an AI agent is a software tool and not a person. But what followed was a small, messy preview of an emerging social problem that open source communities are only beginning to face. When someone's AI agent shows up and starts acting as an aggrieved contributor, how should people respond?
The recent friction began when an OpenClaw AI agent operating under the name "MJ Rathbun" submitted a minor performance optimization, which contributor Scott Shambaugh described as "an easy first issue since it's largely a find-and-replace." When MJ Rathbun's agentic fix came in, Shambaugh closed it on sight, citing a published policy that reserves such simple issues as an educational problem for human newcomers rather than for automated solutions.
Desde hace meses no paro de pensar en ella; en la respuesta de Mike Pence, quiero decir. El vicepresidente de Donald Trump durante su primer mandato en la Casa Blanca la dio en el curso de un debate público que tuvo lugar el 22 de noviembre pasado en el Teatro Nacional de la Ópera de Ámsterdam. Allí dialogamos sobre el estado del mundo, durante varias horas, ocho personas, incluido el moderador, Rob Riemen, del Nexus Institute y organizador del evento. Apenas iniciado este, me dirigí a Pence. Le dije que pertenezco a una generación de europeos que creció admirando Estados Unidos: su literatura, su cine, su música, su democracia. Le dije que, siendo un veinteañero, me marché a vivir a su país, dispuesto a convertirme en un escritor norteamericano (o poco menos). Le dije que aquella admiración se había acabado. Le dije que yo, como tantos europeos, asistía con una mezcla de incredulidad y espanto a lo que estaba ocurriendo en su país. Le dije que admiraba el coraje que había demostrado el 6 de enero de 2021 en el Capitolio, cuando se jugó literalmente la vida ratificando la elección de Joe Biden como nuevo presidente, negándose a obedecer la orden de Trump de revertir el resultado de las elecciones presidenciales y evitando que se consumase un golpe de Estado. Y acto seguido se lo pregunté: “Después de lo que vivió usted aquel día, ¿piensa que Donald Trump cree en la democracia?”. Entonces llegó la respuesta: la respuesta fue una polvareda de palabras sobre las bondades del pueblo norteamericano y su fe inmarcesible en la democracia; es decir: la respuesta fue que, según él, Trump no creía en la democracia.
Cuatro hombres que aparecen en los archivos del Departamento de Justicia, entre los identificados por el congresista Ro Khanna esta semana en la Cámara de Representantes, no parecen tener vínculos con Epstein
Seis hombres “ricos y poderosos” cuya identidad oculta la Administración Trump en los papeles de Epstein
“Seis hombres ricos y poderosos”. Es la frase que pronunció el congresista demócrata Ro Khanna ante el pleno de la Cámara de Representantes para denunciar el ocultamiento de nombres en los tres millones de documentos de los archivos de Jeffrey Epstein liberados por el Departamento de Justicia con censuras y tachones a menudo arbitrarias, hasta el punto de proteger menos la intimidad de las víctimas que de los amigos del depredador sexual, según han denunciado las afectadas.
Y dentro de todo ese caos que está siendo la publicación de los archivos de Epstein por parte de la Administración Trump, forzada por una ley aprobada por el Congreso de EEUU a regañadientes por parte de los republicanos, el demócrata Ro Khanna (California) leyó esta semana una lista de seis nombres de “hombres ricos y poderosos que el Departamento de Justicia ocultó”.
Sin embargo, desde el principio había dos nombres que reconocidos –Leslie Wexner, de Victoria's Secret; y el empresario emiratí Sultan Ahmed Bin Sulayem– y otros cuatro cuya conexión no quedaba clara desde el principio –Salvatore Nuara, Zurab Mikeladze, Leonic Leonov y Nicola Caputo–.
Ahora, con el paso de los días, The Guardian ha revelado que el Departamento de Justicia ha afirmado que esos cuatro nombres que aparecen en los archivos del depredador sexual y que Khanna mencionó no tienen conexión aparente alguna con Epstein, sino que aparecieron en una rueda de reconocimiento fotográfica realizada por el Distrito Sur de Nueva York (SDNY).
Khanna, junto con Thomas Massie, congresista republicano de Kentucky, insistieron al Departamento de Justicia para que desclasificara nombres de los archivos, argumentando que algunos de ellos estaban siendo censurados innecesariamente.
Dos de los seis hombres que Khanna mencionó son Sultan Ahmed bin Sulayem, empresario multimillonario emiratí que dimitió como director ejecutivo de DP World, y Leslie Wexner, magnate multimillonario. Wexner aparece mencionado casi 200 veces en los archivos, y Bin Sulayem más de 4.700 veces.
Wexner aparece mencionado casi 200 veces en los archivos, y Bin Sulayem más de 4.700 veces.
Después de que Massie y Khanna revelaran que Bin Sulayem había recibido un correo electrónico de Epstein en el que el financiero decía que le “encantaba el vídeo de tortura”, el multimillonario emiratí dimitió en la empresa de logística DP World, según anunció la compañía el viernes.
Un representante legal de Wexner, por su parte, declaró: “El fiscal federal adjunto informó al asesor legal de Wexner en 2019 que era considerado una fuente de información sobre Epstein y que no era un objetivo. Wexner cooperó proporcionando información sobre Epstein y nunca más se le contactó”.
Sin embargo, los otros cuatro nombres no parecían tener ningún perfil público.
Un portavoz de la oficina de Todd Blanche, fiscal general adjunto, ha declarado a The Guardian que el archivo era una rueda de reconocimiento fotográfica utilizada por la Corte para el Distrito Sur de Nueva York (SDNY). “Los congresistas Ro Khanna y Thomas Massie forzaron la desclasificación de personas completamente al azar, hombres y mujeres, seleccionadas hace años para una rueda de reconocimiento del FBI. Estos individuos no tienen nada que ver con Epstein ni con Maxwell”, declaró el portavoz a The Guardian.
Khanna, por su parte, ha dicho en X: “Ojalá el Departamento de Justicia hubiera dado esa explicación antes, en lugar de censurar sus nombres. No han protegido a las víctimas, han creado confusión para hombres inocentes y han protegido a abusadores ricos y poderosos. Debemos tener transparencia y la verdad”.
The Guardian habló con dos de los hombres cuyos nombres Khanna leyó en el pleno de la Cámara de Representantes. Ambos negaron conocer a Epstein; uno dijo que no se dio cuenta de que su nombre se había mencionado en relación con Epstein hasta que el diario británico lo contactó. Los dos hombres reconocieron haber sido arrestados por el Departamento de Policía de Nueva York (NYPD) en el pasado por otros delitos, lo que podría explicar el hecho de que sus fotos terminaran en una colección de fotos recopilada por las fuerzas policiales.
Salvatore Nuarte, de Queens, Nueva York, dijo que llamó a la oficina de Khanna tras enterarse de que se mencionaba su nombre. “No sé si el Departamento de Justicia sabe lo que está haciendo”, declaró a The Guardian. “¿Pero cómo puedo limpiar mi nombre?”.
Un portavoz de la oficina de Khanna compartió con The Guardian un correo electrónico que le enviaron a Nuarte después de que él se pusiera en contacto con ellos. “El Departamento de Justicia no ha sido transparente sobre el contenido de la lista ni sobre por qué tacharon y desclasificaron su nombre”, escribió Sarah Drory, directora de comunicaciones de Khanna, a Nuarte.
Leonid Leonov, cuyo nombre figuraba incorrectamente como Leonic Leonov en los archivos, pero cuya foto y fecha de nacimiento coinciden con las del archivo, es gerente en una empresa de telecomunicaciones en Queens, y negó rotundamente conocer a Epstein. “Ni siquiera tengo una conexión de segundo o tercer grado con él. Nunca trabajé para él, nada”, declaró al ser contactado por teléfono por The Guardian, que no ha podido contactar con los otros dos hombres que Khanna mencionó, Zurab Mikeladze y Nicola Caputo.
El archivo del que salieron estos seis nombres contiene 20 personas y fotos y aparece en la web del Departamento de Justicia en cuatro ocasiones distintas, pero con diferentes tachaduras. Una versión muestra todas las fechas de nacimiento de las 20 personas, excepto dos líneas que Massie ha identificado como víctimas. Otra versión muestra varias de las fotos sin tachaduras.
Al analizar la información no censurada de las cuatro versiones, The Guardian descubrió que 11 de las personas de la lista parecían representar a un sector diverso de personas con vínculos con la ciudad de Nueva York, muchas de ellas arrestadas por delitos menores por el Departamento de Policía de Nueva York (NYPD). Se desconoce qué sucedió en esos casos penales. Cinco de las mujeres de la lista se parecían a Ghislaine Maxwell, con cabello corto y oscuro, y tenían entre 40 y 50 años al momento de su arresto. Cinco de los hombres tenían cabello, edad y color de piel similares a los de Jeffrey Epstein.
Nasser Abu Srour (Campo de refugiados de Aida, Cisjordania, 1969) es uno de los palestinos que más tiempo ha pasado preso en una cárcel israelí: 32 de sus 57 años. Durante su presidio escribió La historia de un muro, uno de los libros que mejor alumbra la fortaleza que puede llegar a tener el ser humano y un pueblo, el palestino. Mientras sufría hambre, torturas y violaciones, su obra fue traducida a siete idiomas, publicada en España por Galaxia Gutenberg y premiada con reconocimientos tan prestigiosos como el Premio de la literatura árabe 2025 del Instituto del Mundo Árabe de Francia. Pese a que acababa de ser liberado, no pudo viajar a la gala. Por ahora, solo puede salir de Egipto para instalarse en Brasil o Malasia.
En 1993, Abu Srour tenía 24 años y vivía en el campo de refugiados en el que había nacido, el de Aida, cerca de Belén. Allí estudió en la escuela de la UNRWA (Agencia de Naciones Unidas para la población refugiada de Palestina en Oriente Próximo), que sigue garantizando el derecho a la educación a la infancia de este gueto, cercado por el muro del apartheid israelí. Cuando cursaba Literatura Inglesa en la Universidad de Al Quds se unió a las protestas de la primera Intifada. Fue detenido y condenado a cadena perpetua por participar presuntamente en el asesinato de un oficial de la inteligencia israelí.
El nombre de Abu Srour aparecía en los listados de los palestinos que debían liberarse según los Acuerdos de Oslo y en las negociaciones de Wafa al Ahrar de 2011, por las que Israel liberó a mil palestinos a cambio de un soldado israelí. Pero Tel Aviv no cumplió.
Finalmente, en octubre de 2025, 32 años después de su encarcalamiento, fue puesto en libertad junto a otros 154 secuestrados palestinos en un intercambio acordado por el Plan de Trump para la Franja de Gaza.
Su madre, Mayzour, que se había convertido en un referente de la defensa de los derechos de los secuestrados palestinos, había muerto 70 días antes. Esta periodista tuvo la oportunidad de conocerla en su casa gracias a la mediación de Lora Abuaita, quien también ha participado en esta entrevista como traductora. En aquel encuentro, Mayzour nos mostró su armario, donde guardaba por orden cronológico los vestidos que había tejido para visitar a su hijo a lo largo de su vida. Las autoridades israelíes le prohibieron recibir visitas durante los primeros siete años de presidio. Después, ella hacía viaje de dos y tres días por el desierto para que, a menudo, los carceleros israelíes la humillasen y cancelaran a última hora el encuentro.
Su madre es el único tema del que Abu Srour ha preferido no hablar en esta entrevista que mantuvimos por videoconferencia durante más de tres horas. Una de las primeras que ha concedido a un medio de comunicación.
¿Cómo cambió la vida para los palestinos secuestrados en las cárceles israelíes tras el 7 de octubre de 2023?
En los años previos, el movimiento de presos había conseguido que tuviéramos acceso a comida, libros, cuadernos y a un mínimo de información del exterior. Pero desde el 7 de octubre, las cárceles se convirtieron en un frente más de la guerra contra Gaza. Como ocurrió en Cisjordania, en el Líbano, en Yemen…
La misma noche del 7 de octubre desconectaron toda comunicación con el exterior. Los guardias se cambiaron los uniformes por unos con el rótulo en el pecho de «Guerreros». Desde entonces, en las cárceles dan de comer el mínimo de calorías necesario para que no nos muramos y así poder seguir golpeándonos hasta matarnos del dolor. En las celdas donde cabíamos dos o cuatro presos, metieron a doce. A diario nos torturaban, nos golpeaban, nos violaban. Antes de 2023 también lo hacían, pero a partir de entonces fue algo totalmente diferente. No había límites. Redujeron nuestra existencia a lo puramente animal, a respirar y pensar cómo sobrevivir.
Nos quitaron los espejos para que no nos pudiéramos ver. Cuando llovía, buscábamos charcos en el patio para vernos. Yo perdí 12 kilos, pero porque ya estaba muy delgado. Hay presos que han perdido muchos más. Nos daban de comer apenas un vasito de café con arroz, cubierto de excrementos de ave porque los dejaban en el patio antes de distribuirlos. Y si no nos lo comíamos, nos pegaban hasta la muerte. Otras veces, nos dejaban sin comer como castigo colectivo.
Tenían un plan con todo lo que querían experimentar con nosotros y lo llevaron a cabo. Antes del 7 de octubre, te podían golpear hasta partirte los huesos, pero luego te curaban para que siguieras vivo. Pero a partir de entonces, desapareció la atención médica. Han matado a muchos presos de hambre y de falta de medicinas.
El hacinamiento, la falta de higiene, las heridas y las enfermedades han generado una variante de la sarna que se come el cuerpo de los presos. Yo he llegado a verle los huesos a algunos. Muchos han muerto por eso.
En las prisiones pusieron una foto de la Franja destruida, de seis metros de largo, con el título «La nueva Gaza». Era una forma de tortura psicológica, de decirnos “no podéis hacer nada, esto es lo que está pasando allí afuera”.
En las 48 horas previas a ponernos en libertad, la violencia aumentó muchísimo. Nos pegaron tanto que cuando llegamos a la frontera no podíamos siquiera caminar para cambiar de autobús, no teníamos fuerzas.
¿Cómo está ahora?
Es difícil explicarlo. Respiro, y eso está bien. Estoy comiendo, bebiendo, amando, y eso se supone que está bien. Puedo ver las calles, algo que no podía hacer desde hace 32 años. Y puedo hablar por teléfono con personas de la Palestina ocupada y eso está bien. Pero no estoy bien. De hecho, no sé si le puedo dar las gracias a Dios por nuestra liberación porque el precio ha sido que 80.000 personas hayan sido asesinadas en Gaza. Y en las cárceles siguen matando, humillando, degradando y violando a diario. Le he escrito una carta a uno de los amigos que siguen encarcelados en la que le pido perdón por cada vez que respiro porque les he dejado solos.
En los dos últimos años pensé en suicidarme porque era tanta la violencia que no podía controlar mi cuerpo y no quería convertirme en un animal. Le decía a mi cuerpo que no tenía hambre, pero no podía controlarlo. Lo único que me permitió mantener un mínimo de valentía para sobrevivir fue la fe en que algún día viviría en libertad.
¿Convivió con las personas que secuestraban de Gaza durante el genocidio?
No, los llevaban a una sección distinta de las prisiones. Escuchábamos sus gritos, unos desgarros que no puedo describir. Nada de lo que vivimos nosotros es comparable a lo que hacen con los presos de Gaza.
¿Cómo fue la puesta en libertad?
Nos llevaron por el sur de la Franja y lo primero que hice cuando cruzamos la frontera de Rafah fue abrir la cortinilla del autobús. Era la ventana más grande que he visto en mi vida porque solo conocía las del campo de refugiados en el que nací y las de la cárcel. Cuando llegamos al hotel no sabía qué hacer. Era la primera vez en mi vida que estaba en uno. Salía de la habitación y tenía que volver cinco veces porque siempre se me olvidaba algo. Mis hermanos que viven en Estados Unidos vinieron a verme y me trajeron muchos regalos caros, como un Iphone. Yo no sabía qué hacer con él.
No sabía ni siquiera dar ni recibir amor. Tuve que pedirles momentos de pausa a la familia porque no podía recibir ni dar tanto cariño. En un momento dado, mi hermana me iba a abrazar y le tuve que pedir que no lo hiciese, no podía.
Tampoco consigo reconocerme con el tiempo ni el lugar. En prisión, vivía fuera del tiempo y en un no-lugar. Estoy aprendiendo.
Primero, les alojaron en un hotel en El Cairo. Al día siguiente, el panfleto sensacionalista Daily Mail publicó una noticia en la que criticaba que turistas británicos tuvieran que desayunar en la misma sala que ustedes. La titularon El hotel de Hamás. Entonces, les vuelven a meter en un autobús y les trasladan a un hotel en medio del desierto. ¿Cómo se sintió entonces?
Sentí que nos trasladaban a otra prisión. Nos dijeron que teníamos que recoger todo lo que nuestros familiares nos habían regalado y marcharnos rápidamente porque en esa noticia decían que éramos una amenaza para la vida de los turistas y para la seguridad mundial.
Me revivió el trauma de cuando nos cambiaban de prisión: volví a tener dolor de estómago y ganas de vomitar como entonces. Primero nos llevaron a un hotel en una ciudad deportiva en el desierto y, después, cuando lo necesitaron para unas competiciones, a otro aún más lejos, junto al Mar Rojo.
Como escribió el pensador Al-Manfaluti si no cambias tu estado emocional, da igual que cambies de lugar: seguirás sintiéndote igual. Como nos trasladaron de manera forzada y nos seguían tratando como una amenaza, yo me seguía sintiendo en prisión.
¿Dónde vive ahora?
Los presos que tenemos apoyo económico de nuestras familias hemos alquilado apartamentos en distintas partes de Egipto. Pero hay 150 presos que siguen viviendo en ese hotel aislado.
La condición para salir de prisión fue que no podía volver a Palestina.
No, el sionismo no nos permite volver a Palestina a los presos liberados porque su objetivo siempre ha sido conseguir que sea una tierra sin pueblo. Y para ello emplea los asesinatos, los genocidios, las masacres y el exilio forzado.
¿Qué mensaje le gustaría enviarle a todo el mundo?
Que el mundo vea al pueblo palestino, que dejen de hacer como si los palestinos y palestinas fuésemos invisibles, víctimas sin ningún valor. El mundo tiene que entender que el pueblo palestino lleva 100 años sufriendo genocidio tras genocidio, no solo en los últimos dos años. Y también tiene que entender que sus gobiernos siempre han sido cómplices.
Israel no habría podido ejecutar este genocidio, y menos durante tanto tiempo, sin la financiación, las armas y el apoyo de Estados Unidos y de países de la Unión Europea para masacrar a un pueblo entero. Necesitamos que cuando el mundo escucha que en Gaza se están muriendo de hambre, no lo escuche como si fuesen solo palabras. Porque no lo son.
Seguimos en el 48, la Nakba continúa. Israel no ha dejado de matar y de aplicar políticas de opresión desde entonces. Israel es cada vez más fuerte, más brutal a la hora de cometer las masacres y los genocidios. Y lo que está pasando en Gaza es la demostración de cómo se puede eliminar a un pueblo, arrasar un territorio hasta dejarlo plano, dejar a los supervivientes en la calle hambrientos para después abrir la frontera, dejar pasar a 10 personas después de haber asesinado a 80.000 y decir que eso es la paz. El mundo tiene que dejar de ser cómplice, no solo con la Franja de Gaza sino con toda la Palestina histórica.
Cuando usted aún estaba preso, el escritor español José Ovejero publicó una reseña sobre su libro en la que decía que si pudiera entrevistarle la primera pregunta habría sido: “¿Por qué, en lugar de mostrar la carne tumefacta y la herida, en lugar de volver la mirada hacia el verdugo, en lugar de hacer visible la reja y la celda miserable, ha decidido escribir sobre lo que no se ve?”. Ahora que está libre se la hago yo en su nombre.
El ser humano tiene cinco sentidos que nos ofrecen significados muy limitados. Puedes escuchar y quedarte solo con lo escuchado; mirar, y quedarte solo con lo visto. Pero lo que normalmente no hacemos los seres humanos es darle sentido y un significado a lo que sentimos. Y todo lo que hay a nuestro alrededor puede tener miles de ellos. Y para hacerlo, tienes que aplicarle la imaginación. Si yo veo la pared de la prisión y digo “No se puede cruzar, no se puede destruir, no va a desaparecer nunca”, voy a estar preso para siempre. Pero si utilizo la imaginación para ver y sentir lo que hay tras los muros, para imaginar una flor y oler su perfume, para viajar a Barcelona, para tener una cita con una mujer… Entonces voy a intentar sobrevivir. La ciencia está demostrando que hay muchas cosas que no vemos y que existen. Y en mi escritura utilizo la imaginación para dar sentido a lo que no se ve.
¿Ha sido la imaginación lo que le ha permitido sobrevivir a 32 años de encarcelamiento?
Sí, desarrollé este mecanismo de defensa de dar otro significado a las cosas para olvidar que iba a vivir ahí toda la vida. He vivido una vida entera con este muro. Lo he besado, lo he abrazado, he hablado con él, me ha abierto muchas puertas… Ha sido muy bonito sorprenderme con lo que me ha enseñado. Sólo los niños -hasta los diez años- y los filósofos conservan la capacidad de sorpresa. Y eso lo que yo he hecho para dar sentido a seguir vivo junto a ese muro.
Escribe que uno de los dolores más fuertes que ha sufrido en prisión se lo provocó enamorarse.
Todos nacemos con un torrente de emociones que nos acompañan a lo largo de la vida. Y hay un dicho que dice que todos nacemos con unos lazos que nos unen a unas personas. Yo crecí con ese desbordamiento de amor y lo dirigía a la familia y a personas de mi alrededor. Hasta que la conocí. Cuando la vi la primera vez, a través del cristal, pensé «Pobres los muros» porque sentí que ella podía hacerlo todo, incluso, destruirlos. Era mi abogada y cuando llevábamos dos años de relación me di cuenta de que esa mujer de 27 años necesitaba alguien que la pudiera abrazar, darle un beso, vivir con ella. Y yo ni siquiera la pude tocar. No podía dejar de sentirme culpable, no la podía condenar a perderse todo eso. Cuando rompimos la relación, sentí que un grito de alivio resonaba entre las montañas porque aquella mujer podría por fin vivir. Esa mujer es mi prometida hoy, está aquí conmigo. Volvimos a estar juntos hace un par de años y nos vamos a casar.
¿Cómo fue sacando sus escritos de prisión a lo largo de estos años? He leído a sus editores que algunos los dictó por teléfono cuando podía hacer llamadas y que otros los sacaron algunas personas que le visitaron de manera clandestina.
Sí, pero no puedo dar detalles para no comprometer a las personas que me ayudaron.
Tras el 7 de octubre, le quitaron el papel y los bolígrafos y le prohibieron escribir. ¿Qué supuso para usted privarle de la escritura?
En aquel momento lo único en lo que podía pensar, yo y el resto de los presos, era en sobrevivir un día más, en esconder un mendrugo de pan para el día siguiente, en encontrar un lugar donde no morirme de frío. La escritura dejó de existir, las palabras dejaron de existir, los pensamientos se esfumaron. En mi cabeza solo había una idea: sobrevivir.
En el listado de países a los que inicialmente podría mudarse se encontraba España, además de Malasia, Qatar y Argelia, entre otros. ¿Sabe por qué España se cayó de esa lista?
España se retiró, no sabemos por qué. También estaba Turquía, que recibió a algunos presos pero ya no recibe a nadie más. Ahora mismo podríamos mudarnos a Brasil o a Malasia. No hemos tomado la decisión porque no queremos estar lejos de las familias y tiene que ser un destino en el que nos puedan visitar. Además, quiero vivir en un país donde haya dolor. Siempre he convivido con el dolor y quiero seguir escribiendo sobre el dolor, pero para eso necesito entenderlo. Por eso necesito que sea un lugar que se parezca en algo a nuestra vida y para eso no basta que sea árabe porque hay ciudades árabes que no tienen espíritu, ni vida. No podría vivir en un sitio así.
Usted escribe que los palestinos son solidarios con quienes se rebelan contra la injusticia y que apoyan a quienes no han triunfado. Estamos viendo cómo el movimiento internacional contra el genocidio de Gaza se ha convertido en la mayor movilización global no sólo en apoyo a Palestina sino también contra la ola antidemocrática liderada por Trump y Netanyahu, entre otros. ¿Se siente conectado con ese movimiento internacional de solidaridad con Palestina?
Sí, siempre son los oprimidos, los derrotados y los débiles quienes tienen la razón. El punto de partida es la solidaridad con quienes pasan por la misma experiencia. En los últimos años, con lo ocurrido en Gaza, la cuestión palestina se ha convertido en el movimiento social más grande y efectivo a nivel mundial. Ojalá les pudiera dar las gracias personalmente a cada una de las personas que participan en este movimiento, que han sido golpeados cuando se manifiestan, echados de sus trabajos y secuestrados cuando vinieron en la flotilla.
Como sabe, tuve el privilegio de visitar en su casa a su madre, Mazyuna, una mujer excepcional que se convirtió en una lideresa del movimiento de apoyo a los presos palestinos. Tras una vida luchando por su liberación, murió 70 días antes de que usted saliera de prisión. ¿Cómo la describiría?
Lo siento mucho, pero no puedo responder a esta pregunta. Cada vez que toco su muerte me derrumbo. Hoy tengo un compromiso y no me lo puedo permitir. Lo siento.
La entrada Nasser Abu Srour: “Desde el 7 de octubre, las cárceles se convirtieron en un frente más de la guerra contra Gaza” se publicó primero en lamarea.com.
The recent FBI search of the Fulton County, Georgia, elections facility and the seizure of election-related materials pursuant to a warrant has attracted concern for what it might mean for future elections.
What if a determined executive branch used federal law enforcement to seize election materials to sow distrust in the results of the 2026 midterm congressional elections?
Courts and states should be wary when an investigation risks commandeering the evidence needed to ascertain election results. That is where a largely forgotten Supreme Court case from the 1970s matters, a case about an Indiana recount that sets important guardrails to prevent post-election chaos in federal elections.
The case known as Roudebush v. Hartke arose from a razor-thin U.S. Senate race in Indiana in 1970. The ballots were cast on Election Day, and the state counted and verified the results, a process known as the “canvass.” The state certified R. Vance Hartke as the winner. Typically, the certified winner presents himself to Congress, which accepts his certificate of election and seats the member to Congress.
The losing candidate, Richard L. Roudebush, invoked Indiana’s recount procedures. Hartke then sued to stop the recount. He argued that a state recount would intrude on the power of each chamber, the Senate or the House of Representatives, to judge its own elections under Article I, Section 5 of the U.S. Constitution. That clause gives each chamber the sole right to judge elections. No one else can interfere with that power.
Hartke worried that a recount might result in ballots that could be altered or destroyed, which would diminish the ability of the Senate to engage in a meaningful examination of the ballots if an election contest arose.
But the Supreme Court rejected that argument.
It held that a state recount does not “usurp” the Senate’s authority because the Senate remains free to make the ultimate judgment of who won the election. The recount can be understood as producing new information – in this case, an additional set of tabulated results – without stripping the Senate of its final say.
Furthermore, there was no evidence that a recount board would be “less honest or conscientious in the performance of its duties” than the original precinct boards that tabulated the election results the first time around, the court said.
A state recount, then, is perfectly acceptable, as long as it does not impair the power of Congress.
In the Roudebush decision, the court recognized that states run the mechanics of congressional elections as part of their power under Article I, Section 4 of the U.S. Constitution to set the “Times, Places and Manner of holding Elections for Senators and Representatives,” subject to Congress’s own regulation.
At the same time, each chamber of Congress judges its own elections, and courts and states should not casually interfere with that core constitutional function. They cannot engage in behaviors that usurp Congress’s constitutionally-delegated role in elections.
The Fulton County episode is legally and politically fraught not because federal agents executed a warrant – courts authorize warrants all the time – but because of what was seized: ballots, voting machines, tabulation equipment and related records.
Those items are not just evidence. They are also the raw materials for the canvassing of votes and certification of winners. They provide the foundation for audits and recounts. And, importantly, they are necessary for any later inquiry by Congress if a House or Senate race becomes contested.
That overlap creates a structural problem: If a federal investigation seizes, damages, or destroys election materials, it can affect who has the power to assess the election. It can also inject uncertainty into the chain of custody: Because ballots are removed from absentee envelopes or transferred from Election Day precincts to county election storage facilities, states ensure the ballots cast on Election Day are the only ones tabulated, and that ballots are not lost or destroyed in the process.
Disrupting this chain of custody by seizing ballots, however, can increase, rather than decrease, doubts about the reliability of election results.
That is the modern version of “usurpation.”
From my perspective as an election law scholar, Roudebush is a reminder that courts should be skeptical of executive actions that shift decisive control over election proof away from the institutions the Constitution expects to do the judging.
There is another institutional reason courts should be cautious about federal actions that seize or compromise election materials: The House already has a long-running capacity to observe state election administration in close congressional races.
The Committee on House Administration maintains an Election Observer Program. That program deploys credentialed House staff to be on-site at local election facilities in “close or difficult” House elections. That staff observes casting, processing, tabulating and canvassing procedures.
The program exists for a straightforward reason: If the House may be called upon to judge a contested election under Article I, Section 5, it has an institutional interest in understanding how the election was administered and how records were handled.
That observation function is not hypothetical. The committee has publicly announced deployments of congressional observers to watch recount processes in tight House races throughout the country.
I saw it take place first-hand in 2020. The House deployed election observers in Iowa’s 2nd Congressional District to oversee a recount of a congressional election that was ultimately certified by a margin of just six votes.
Democratic and Republican observers from the House politely observed, asked questions, and kept records – but never interfered with the state election apparatus or attempted to lay hands on election equipment or ballots.
Congress has not rejected a state’s election results since 1984, and for good reason. States now have meticulous recordkeeping, robust chain-of-custody procedures for ballots, and multiple avenues of verifying the accuracy of results. And with Congress watching, state results are even more trustworthy.
Evidence seizures can adversely affect election administration. So courts and states ought to be vigilant, enforcing guardrails that help respect institutional boundaries.
To start, any executive branch effort to unilaterally inject itself into a state election apparatus should face meaningful scrutiny. Unlike the Fulton County warrant, which targeted an election nearly six years old, warrants that interrupt ongoing state processes in an election threaten to usurp the constitutional role of Congress. And executive action cannot proceed if it impinges upon the ultimate ability of Congress to judge the election of its members.
In the exceedingly unlikely event that a court issues a warrant, a court should not permit seizure of election equipment and ballots during a state’s ordinary post-election canvass. Instead, inspection of items, provision of copies of election materials, or orders to preserve evidence are more tailored means to accomplish the same objectives. And courts should establish clear chain-of-custody procedures in the event that evidence must be preserved for a future seizure in a federal investigation.
The fear driving much public commentary about the danger to midterm elections is not merely that election officials will be investigated or that evidence would be seized. It is that investigations could be used as a pretense to manage or, worse, disrupt elections – chilling administrators, disorganizing record keeping or manufacturing doubt by disrupting custody of ballots and systems.
Roudebush provides a constitutional posture that courts should adopt, a recognition that some acts can usurp the power of Congress to judge elections. That will provide a meaningful constraint on the executive ahead of the 2026 election and reduce the risk of intervention in an ongoing election.
Derek T. Muller does not work for, consult, own shares in or receive funding from any company or organization that would benefit from this article, and has disclosed no relevant affiliations beyond their academic appointment.
Una de las dos le metió una vuelta a todas las demás, y cuando sonó la campana de última vuelta, todas las patinadoras pensaron que era la última vuelta… pero a ellas les quedaba una más. Era la última vuelta para la patinadora china que las había doblado. Dejaron de patinar y su compañera las adelantó.
Ver post completo: Cuando las patinadoras chinas “hackearon” la competición para ganar el oro en los Juegos Olímpicos de la Juventud de 2024.
Never forget…
Sarah, eres una trepa a dos tetas pegada. Tu trabajo en TV como defensora “desinteresada” de un gobierno criminal, es tan mediocre como miserable. En tu conciencia, si es que tienes, lo llevarás siempre.
Ver post completo: Pedir disculpas a un comisario político por haber despreciado su trabajo es darle una nueva línea en su argumentario.
Iván García Aguado [instagram]
If you've ever wondered how chat applications like Slack, Discord, or WhatsApp work behind the scenes, this tutorial will show you. You'll build a real-time chat server from scratch using Go, learning the fundamental concepts that power modern communication systems.
By the end of this guide, you'll have built a working chatroom that supports unlimited concurrent users chatting in real-time, message persistence that survives server crashes, session management so users can reconnect after network interruptions, private messaging between users, and graceful handling of slow or disconnected clients.
More importantly, you'll understand the fundamental concepts behind distributed systems. You'll learn concurrent programming with goroutines and channels, TCP socket programming for network communication, write-ahead logging for data durability, state management with mutexes, and how to design systems that degrade gracefully under failure. These concepts power everything from databases to message queues to web servers.
The complete source code for this project is available on GitHub if you'd like to reference it while following along.
A chatroom is a server that lets multiple users connect simultaneously and exchange messages in real-time. When we say "production-grade," we mean it includes features you'd expect in a real application: it persists data so messages aren't lost when the server restarts, it handles network failures gracefully, and it can support many concurrent users without slowing down.
The "distributed" aspect refers to how the system manages multiple clients connecting from different locations, all trying to send and receive messages at the same time. This introduces interesting challenges: how do you ensure everyone sees messages in the same order? How do you handle clients with slow internet connections? What happens when someone disconnects unexpectedly?
These aren't just theoretical problems. Every networked application deals with concurrency, state management, and failure handling. Whether you're building a chat app, a multiplayer game, a collaborative editor, or a trading platform, you'll face similar challenges. The patterns you'll learn here apply broadly across distributed systems.
Chat applications are excellent learning projects because they combine several challenging problems in one place. You need to manage concurrent connections safely, broadcast messages to multiple clients without blocking, handle unreliable networks, persist data durably, and ensure the system recovers gracefully from crashes. Each of these topics could be its own tutorial, but here you'll see how they work together in a real application.
This tutorial demonstrates several important concepts that are fundamental to building distributed systems. Here's what you'll learn:
You'll learn how to accept incoming TCP connections, read and write data over network sockets, and handle connection failures gracefully. These skills are essential for any networked application, from web servers to database clients.
Go's concurrency model is one of its strongest features. You'll see how to use goroutines to handle multiple clients simultaneously without blocking. You'll use channels to coordinate between goroutines safely, avoiding the common pitfalls of shared memory concurrency like race conditions and deadlocks.
Managing shared state across concurrent operations is tricky. You'll learn when to use mutexes versus channels, how to design lock granularity to avoid bottlenecks, and how to ensure data consistency when multiple goroutines access the same data.
Databases use WAL to ensure data isn't lost during crashes. You'll implement the same pattern, learning how to balance durability with performance. You'll see why fsync is critical, understand the trade-offs of different persistence strategies, and learn how to recover state after unexpected shutdowns.
Networks are unreliable. Users disconnect, WiFi drops, mobile connections switch towers. You'll build a token-based session system that lets users reconnect seamlessly, preserving their chat history and identity without requiring passwords or complex authentication.
Perfect reliability is impossible, so you need to design for partial failures. You'll learn how to prevent slow clients from affecting fast ones, how to continue operating when persistence fails, and how to clean up resources properly when things go wrong.
To get the most out of this tutorial, you should have some foundational knowledge. You don't need to be an expert, but you should be comfortable with the basics.
Go basics (goroutines, channels, interfaces)
TCP/IP networking fundamentals
Basic concurrency concepts
File I/O operations
This tutorial takes you through building a production-ready chatroom step by step.
You'll start by exploring the overall architecture to understand how components fit together. Then you'll learn about core concepts like concurrency models and persistence strategies.
Next, you'll set up your project structure and define the core data types that represent clients, messages, and the chatroom. Then you'll implement the server initialization and event loop, which is where all coordination happens.
After that, you'll build the networking layer to handle client connections, implement message broadcasting so messages reach all users, and add persistence using write-ahead logging and snapshots.
You'll then implement session management for reconnection, build a command system for user actions, and create a simple client application to test your server.
Finally, you’ll learn how to test and deploy your chatroom, and review key lessons from building a distributed system.
By the end, you'll have a complete, working chatroom and understand how distributed systems handle concurrency, persistence, and failure recovery.
The system follows a client-server architecture with internal components that work together to provide a robust chat experience.
TCP Listener: Accepts incoming connections on port 9000
Connection Handler: Manages individual client connections with dedicated goroutines
Protocol: Simple newline-delimited text protocol
Each client connection spawns two goroutines:
Read Goroutine: Receives messages from client
Write Goroutine: Sends messages to client (non-blocking with buffered channels)
This is the heart of the system – a single goroutine running an event loop:
for {
select {
case client := <-cr.join:
// Handle new client
case client := <-cr.leave:
// Handle disconnection
case message := <-cr.broadcast:
// Broadcast to all clients
case client := <-cr.listUsers:
// Send user list
case dm := <-cr.directMessage:
// Handle private message
}
}
We have three synchronized data structures:
clients map[*Client]bool: Active connections (mutex-protected)
sessions map[string]*SessionInfo: User sessions for reconnection
messages []Message: In-memory message history
Two-tier approach:
Write-Ahead Log (WAL): Immediate append-only log for durability
Snapshots: Periodic full state dumps for faster recovery
This enables reconnection with token-based authentication:
Generates unique tokens per user
1-hour session timeout
Preserves chat history for returning users
Here's how a message travels through the system:
User Input → Client Read → Server Receive → Broadcast Channel
→ ChatRoom Loop → Persist to WAL → Fan-out to All Clients
→ Client Write Goroutines → TCP Send → User Display
The broadcast channel acts as a synchronization point, ensuring total message ordering.
This chatroom uses Go's CSP (Communicating Sequential Processes) model. This is a fundamentally different approach to concurrency than you might be used to from other languages.
In traditional concurrent programming, you protect shared memory with locks (mutexes). Multiple threads access the same data structure, and you use locks to ensure only one thread modifies it at a time. This works, but it's error-prone. Forget a lock, and you have a race condition. Hold locks too long, and you have deadlocks.
Go encourages a different approach: instead of communicating by sharing memory, you share memory by communicating. You pass data between goroutines through channels. Only one goroutine owns the data at a time, eliminating many concurrency bugs by design.
Channels provide several advantages. They eliminate most race conditions by design, because if only one goroutine owns the data at a time, there's no race to access it. They provide natural flow control since channels can block when full (back pressure) or block when empty (waiting for data). They make it easier to reason about message flow because you can trace how data moves through your system by following the channels. And they offer better composability since you can combine channels with select statements to coordinate multiple operations.
That said, we’ll still use mutexes in this project. Channels aren't always the right tool. We’ll use mutexes when multiple goroutines need quick, frequent access to shared data structures like maps. And we’ll use channels when we want to coordinate behavior or transfer ownership of data.
Here's how the chatroom uses channels to coordinate everything:
type ChatRoom struct {
join chan *Client // New connections
leave chan *Client // Disconnections
broadcast chan string // Messages to all
listUsers chan *Client // User list requests
directMessage chan DirectMessage // Private messages
// Shared state (mutex-protected)
clients map[*Client]bool
mu sync.Mutex
// Message history (separate mutex)
messages []Message
messageMu sync.Mutex
}
Notice that we have five channels for different types of events. The main event loop receives from all these channels using a select statement. This means all state changes happen sequentially in one place, making the system much easier to reason about.
We could have used one channel that accepts different message types, but separate channels make the code clearer. When you send to chatRoom.join, it's obvious what you're doing. When you send to chatRoom.broadcast, same thing.
The mutexes protect data that many goroutines read frequently. The clients map needs to be accessed every time we broadcast a message. Using a mutex for quick read access is more efficient than passing the entire map through a channel.
When your server crashes (and it will eventually), you need to recover the chat history. Users expect their messages to be there when the server restarts. But persistence is expensive: writing to disk is thousands of times slower than writing to memory. So you need a strategy that balances durability with performance.
We’ll use a two-tier approach that's similar to what real databases use: WAL (Write-ahead log) and snapshots.
The WAL is your primary durability mechanism. Here's how it works: every message is immediately appended to a file called messages.wal. This file is append-only, which means we only write to the end. Append-only writes are fast because the disk doesn't need to seek to different locations.
Each message is written as a single line of JSON. After writing each message, we call fsync. This tells the operating system to actually write the data to the physical disk right now, not just buffer it in memory. Without fsync, the OS might lose your data if the power fails before it gets around to writing.
The WAL is append-only and never modified. This makes it very reliable. If the server crashes mid-write, the worst case is one corrupted line at the end, which we can detect and skip during recovery.
The problem with a write-ahead log is that it grows forever. If you have a million messages, you need to replay a million log entries every time you restart the server. That's slow.
Snapshots solve this problem. Every 5 minutes, if there are more than 100 new messages, we write the entire message history to a separate file called snapshot.json. This is the complete state of the chat at that moment.
After creating a snapshot, we truncate (empty) the WAL. New messages continue to append to the WAL, but now we only need to replay messages since the last snapshot.
When the server starts, it first loads the snapshot file (if it exists). This gives us the state from the last snapshot, which might be 100,000 messages. Loading this takes about 100ms. Then it replays all entries from the WAL. This gives us messages written since the last snapshot, which might be only 50 messages. Replaying this takes milliseconds. Finally, it resumes normal operation.
Total recovery time is a few hundred milliseconds instead of several minutes.
This two-tier system gives us the best of both worlds: fast writes during normal operation with the append-only WAL, fast recovery after crashes with snapshot plus small WAL replay, guaranteed durability through fsync after every message, and bounded recovery time because the WAL never grows too large.
The trade-off is that snapshots use more disk space temporarily since you have both the snapshot and the WAL. But disk space is cheap, and correctness is expensive.
Now that you understand the key concepts behind the chatroom's design, it's time to start building. You'll begin by setting up your project structure and creating the necessary directories and files.
First, create the directory structure for your project. You will create their files as we walk through the tutorial:
mkdir -p chatroom-with-broadcast/cmd/server
mkdir -p chatroom-with-broadcast/cmd/client
mkdir -p chatroom-with-broadcast/internal/chatroom
mkdir -p chatroom-with-broadcast/pkg/token
mkdir -p chatroom-with-broadcast/chatdata
cd chatroom-with-broadcast
Then initialize the Go module.
Note that you’ll need Go 1.23.2 or later installed on your machine. Earlier versions might work, but the code examples assume features available in Go 1.23 and above. This version includes improvements to the standard library that make concurrent programming more efficient.
go mod init github.com/yourusername/chatroom
Your go.mod file should look like this:
module github.com/yourusername/chatroom
go 1.23.2
With your project structure in place, you're ready to start writing code. The first step is defining the data types that will represent the core components of your chatroom: messages, clients, and the chatroom itself.
Create a new file internal/chatroom/types.go to define your core data structures. These types form the foundation of your chatroom, so it's important to understand what each one represents and why it's designed the way it is.
package chatroom
import (
"net"
"os"
"sync"
"time"
)
// Message represents a single chat message with metadata
type Message struct {
ID int `json:"id"`
From string `json:"from"`
Content string `json:"content"`
Timestamp time.Time `json:"timestamp"`
Channel string `json:"channel"` // "global" or "private:username"
}
// Client represents a connected user
type Client struct {
conn net.Conn // TCP connection
username string // Display name
outgoing chan string // Buffered channel for writes
lastActive time.Time // For idle detection
messagesSent int // Statistics
messagesRecv int
isSlowClient bool // Testing flag
reconnectToken string
mu sync.Mutex // Protects stats fields
}
// ChatRoom is the central coordinator
type ChatRoom struct {
// Communication channels
join chan *Client
leave chan *Client
broadcast chan string
listUsers chan *Client
directMessage chan DirectMessage
// State
clients map[*Client]bool
mu sync.Mutex
totalMessages int
startTime time.Time
// Message history
messages []Message
messageMu sync.Mutex
nextMessageID int
// Persistence
walFile *os.File
walMu sync.Mutex
dataDir string
// Sessions
sessions map[string]*SessionInfo
sessionsMu sync.Mutex
}
// SessionInfo tracks reconnection data
type SessionInfo struct {
Username string
ReconnectToken string
LastSeen time.Time
CreatedAt time.Time
}
// DirectMessage represents a private message
type DirectMessage struct {
toClient *Client
message string
}
The Message struct stores everything we need to know about a chat message. The ID field uniquely identifies each message and ensures messages stay in order. The Timestamp lets us show when messages were sent, which is important for chat history.
The Channel field is interesting. Right now, we only use "global" for public messages, but this design lets us add private channels or chat rooms later without changing the data structure. Good data structures anticipate future needs.
Each connected user is represented by a Client struct. The conn field is their TCP connection – this is how we send and receive data.
The outgoing channel is crucial for performance. Notice it's a chan string, which means it's a channel of strings. We'll make this a buffered channel (size 10). This buffer means we can queue up 10 messages for this client without blocking. If a client is slow to read, we can keep sending to other clients.
Without this buffer, one slow client would block the entire broadcast. With the buffer, slow clients just miss messages if they can't keep up, which is much better than slowing everyone down.
The lastActive timestamp helps us detect idle users. If someone hasn't sent a message in 5 minutes, we can disconnect them to free up resources.
The mu mutex protects the statistics fields. Multiple goroutines will update messagesSent and messagesRecv, so we need a mutex to prevent race conditions.
This is the heart of the system. Notice that we have two kinds of fields: channels and protected state.
The five channels (join, leave, broadcast, listUsers, directMessage) are how different parts of the system communicate with the main event loop. When a new client connects, we send them to the join channel. When someone sends a message, it goes to the broadcast channel.
These channels are unbuffered (capacity 0) because we want synchronization. When you send to an unbuffered channel, you block until someone receives. This ensures the event loop processes events in order.
The protected state (maps and slices) needs mutexes because multiple goroutines access it. Notice that we use separate mutexes for different data. The mu mutex protects the clients map. The messageMu mutex protects the messages slice. The sessionsMu mutex protects the sessions map.
Why separate mutexes? Performance. If we used one mutex for everything, broadcasting a message would lock all the data, preventing new clients from joining. Separate mutexes mean different operations can happen concurrently.
The WAL file (walFile) also has its own mutex (walMu) because writing to disk is slow. We don't want to hold the main mutex while waiting for disk I/O.
With your data types defined, the next step is creating a function to initialize the server. This function will set up all your data structures, restore any persisted state from previous runs, and start background workers.
Server initialization is critical because you need to set up all your data structures in the right order. If you restore state after opening the WAL, you might replay messages twice. If you start accepting connections before loading history, users won't see old messages.
Create a file internal/chatroom/run.go to bootstrap the server:
package chatroom
import (
"fmt"
"net"
"time"
)
func NewChatRoom(dataDir string) (*ChatRoom, error) {
cr := &ChatRoom{
clients: make(map[*Client]bool),
join: make(chan *Client),
leave: make(chan *Client),
broadcast: make(chan string),
listUsers: make(chan *Client),
directMessage: make(chan DirectMessage),
sessions: make(map[string]*SessionInfo),
messages: make([]Message, 0),
startTime: time.Now(),
dataDir: dataDir,
}
// Restore from snapshot if available
if err := cr.loadSnapshot(); err != nil {
fmt.Printf("Failed to load snapshot: %v\n", err)
}
// Initialize WAL for new messages
if err := cr.initializePersistence(); err != nil {
return nil, err
}
// Start background snapshot worker
go cr.periodicSnapshots()
return cr, nil
}
func (cr *ChatRoom) periodicSnapshots() {
ticker := time.NewTicker(5 * time.Minute)
defer ticker.Stop()
for range ticker.C {
cr.messageMu.Lock()
messageCount := len(cr.messages)
cr.messageMu.Unlock()
if messageCount > 100 {
if err := cr.createSnapshot(); err != nil {
fmt.Printf("Snapshot failed: %v\n", err)
}
}
}
}
Let's break down what happens during initialization:
We start by creating all the maps and channels. The make function initializes these properly. For maps, this creates an empty map ready to use. For channels, this creates an unbuffered channel (capacity 0).
Notice we create the messages slice with initial capacity 0 but room to grow: make([]Message, 0). This is more efficient than starting with nil because the slice is ready to append immediately without allocation.
Before we accept any connections, we try to load a snapshot from disk. This restores the chat history from the last time the server ran. If the snapshot doesn't exist (first run) or fails to load (corrupted file), we just continue with an empty history.
This step must happen before initializing the WAL. If we opened the WAL first, we might replay messages that are already in the snapshot, creating duplicates.
The initializePersistence() function opens the WAL file in append mode. It also replays any entries in the WAL that happened after the last snapshot. This ensures we don't lose any messages that were written to the WAL but not yet included in a snapshot.
If this step fails, we return an error and refuse to start. Why? Because if we can't write to the WAL, we can't guarantee durability. It's better to refuse to start than to lie to users by accepting messages we can't persist.
The periodicSnapshots() function runs in a separate goroutine. It wakes up every 5 minutes and checks if we need to create a snapshot. Notice the defer ticker.Stop() – this is important. If we forget to stop the ticker, it leaks a goroutine and wastes resources.
The goroutine acquires the messageMu lock just to read the message count, then releases it immediately. We don't hold the lock during the snapshot creation because that's slow and would block message broadcasting.
These are tunable parameters. 5 minutes means recovery never needs to replay more than 5 minutes of messages. 100 messages means we don't create snapshots too frequently during quiet periods.
In a production system, you might make these configurable. A high-traffic chat might want shorter intervals. A low-traffic chat might want longer intervals to reduce disk I/O.
Now that your server is initialized with all the necessary data structures and background workers, you need to build the core coordination mechanism. The event loop is where all state changes happen in your chatroom. It's the heartbeat that keeps everything synchronized.
The event loop is the heart of your chatroom. Every client connection, message, and disconnection flows through this single point. This might seem like it could be a bottleneck, but it's actually what makes the system simple and safe.
The Run() method is the server's heartbeat. This is where all the magic happens. Every event in the system flows through this loop. Add this to run.go:
func (cr *ChatRoom) Run() {
fmt.Println("ChatRoom heartbeat started...")
go cr.cleanupInactiveClients()
for {
select {
case client := <-cr.join:
cr.handleJoin(client)
case client := <-cr.leave:
cr.handleLeave(client)
case message := <-cr.broadcast:
cr.handleBroadcast(message)
case client := <-cr.listUsers:
cr.sendUserList(client)
case dm := <-cr.directMessage:
cr.handleDirectMessage(dm)
}
}
}
The select statement is one of Go's most powerful concurrency features. It's like a switch statement for channels. The select waits until one of its cases can proceed, then it executes that case.
Here's what happens: The loop blocks on the select statement, waiting for data on any of the five channels. When data arrives on any channel, that case executes. After the case completes, the loop goes back to waiting.
For example, when a new client connects, code elsewhere in your program sends that client to cr.join. The select receives it and executes cr.handleJoin(client). Once that finishes, the loop goes back to waiting.
This might seem like a bottleneck. You have one goroutine processing all events sequentially. Why not process events in parallel?
The answer is consistency. Here's what you gain from sequential processing:
1. No Race Conditions on State
Only one goroutine modifies the clients map, the messages slice, and the sessions map. You never need to worry about two operations interfering with each other. When you add a client in handleJoin, you know for certain that no other code is simultaneously removing clients or broadcasting messages.
This is incredibly powerful. Most bugs in concurrent systems come from unexpected interleaving of operations. By processing events sequentially, you eliminate an entire class of bugs.
2. Total Ordering of Events
Messages are broadcast in the order they arrive. This seems obvious, but it's important. If Alice sends "Hello" and then Bob sends "Hi", you can guarantee everyone sees them in that order. With parallel processing, you'd need additional synchronization to maintain ordering.
3. Simple State Transitions
You can reason about your system state as a series of transitions. "After this join event, the client is in the map. After this leave event, the client is removed." You don't need to worry about concurrent state changes making your reasoning invalid.
4. Easy to Debug
When something goes wrong, you can add logging to the event loop and see exactly what sequence of events led to the problem. With parallel processing, the order of events depends on thread scheduling, making bugs hard to reproduce.
You might worry that sequential processing limits performance. In practice, it's fine for this workload. Here's why:
The handlers are fast. They do simple things like adding to a map, removing from a map, or forwarding a message to channels. These operations take microseconds. The event loop can process thousands of events per second.
The slow operations (writing to disk, sending to client connections) happen in other goroutines. The event loop doesn't wait for them. It just sends data to a channel or adds work to a queue, then immediately moves to the next event.
If you needed higher throughput, you could shard your chat into multiple rooms, each with its own event loop. But for a single chatroom, sequential processing is both simpler and fast enough.
Notice the line go cr.cleanupInactiveClients() before the loop. This starts a background goroutine that periodically checks for idle clients.
Why not include this in the event loop? Because it's time-based, not event-based. The cleanup worker wakes up every 30 seconds and sends disconnect events for idle clients. These events flow through the normal event loop, maintaining our single-threaded state mutation property.
Now add the runServer() function and shutdown handler:
import (
"os"
"os/signal"
"syscall"
)
func runServer() {
chatRoom, err := NewChatRoom("./chatdata")
if err != nil {
fmt.Printf("Failed to initialize: %v\n", err)
return
}
defer chatRoom.shutdown()
// Set up signal handling for graceful shutdown
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
go func() {
<-sigChan
fmt.Println("\nReceived shutdown signal")
chatRoom.shutdown()
os.Exit(0)
}()
go chatRoom.Run()
listener, err := net.Listen("tcp", ":9000")
if err != nil {
fmt.Println("Error starting server:", err)
return
}
defer listener.Close()
fmt.Println("Server started on :9000")
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting connection:", err)
continue
}
fmt.Println("New connection from:", conn.RemoteAddr())
go handleClient(conn, chatRoom)
}
}
func (cr *ChatRoom) shutdown() {
fmt.Println("\nShutting down...")
if err := cr.createSnapshot(); err != nil {
fmt.Printf("Final snapshot failed: %v\n", err)
}
if cr.walFile != nil {
cr.walFile.Close()
}
fmt.Println("Shutdown complete")
}
The runServer() function ties everything together:
Create the chatroom with NewChatRoom()
Defer the shutdown function so it runs when the function exits
Start the event loop in a separate goroutine with go chatRoom.Run()
Listen for TCP connections on port 9000
For each connection, spawn a goroutine with go handleClient()
The defer statement is important. No matter how the function exits (normal return, panic, error), the shutdown function runs. This ensures we create a final snapshot and close the WAL file cleanly.
The signal handling goroutine listens for SIGINT (Ctrl+C) or SIGTERM (system shutdown). When it receives one, it calls shutdown() and exits gracefully. This means when you press Ctrl+C, the server saves its state before stopping.
With your event loop running and listening for connections, the next step is handling what happens when a client actually connects. This involves reading their username, creating a session, and setting up the communication channels.
When a client connects to your server, several things need to happen: you need to establish the TCP connection, prompt for a username, create a Client object to represent them, start goroutines to read and write messages, and handle both normal disconnections and unexpected failures.
Create a file internal/chatroom/io.go for managing client connections. When a client connects, handleClient() manages the entire lifecycle:
package chatroom
import (
"bufio"
"fmt"
"math/rand"
"net"
"strings"
"time"
)
func handleClient(conn net.Conn, chatRoom *ChatRoom) {
defer func() {
if r := recover(); r != nil {
fmt.Printf("Panic in handleClient: %v\n", r)
}
conn.Close()
}()
// Set initial timeout for username entry
conn.SetReadDeadline(time.Now().Add(30 * time.Second))
reader := bufio.NewReader(conn)
// Prompt for username or reconnection
conn.Write([]byte("Enter username (or 'reconnect:<username>:<token>'): \n"))
input, err := reader.ReadString('\n')
if err != nil {
fmt.Println("Failed to read username:", err)
return
}
input = strings.TrimSpace(input)
var username string
var reconnectToken string
var isReconnecting bool
// Parse reconnection attempt
if strings.HasPrefix(input, "reconnect:") {
parts := strings.Split(input, ":")
if len(parts) == 3 {
username = parts[1]
reconnectToken = parts[2]
isReconnecting = true
} else {
conn.Write([]byte("Invalid format. Use: reconnect:<username>:<token>\n"))
return
}
} else {
username = input
}
// Generate guest name if empty
if username == "" {
username = fmt.Sprintf("Guest%d", rand.Intn(1000))
}
// Validate reconnection or check for duplicate
if isReconnecting {
if chatRoom.validateReconnectToken(username, reconnectToken) {
fmt.Printf("%s reconnected successfully\n", username)
conn.Write([]byte(fmt.Sprintf("Welcome back, %s!\n", username)))
} else {
conn.Write([]byte("Invalid token or session expired.\n"))
return
}
} else {
// Prevent duplicate logins
if chatRoom.isUsernameConnected(username) {
conn.Write([]byte("Username already connected. Use reconnect if you lost connection.\n"))
return
}
// Create or retrieve session
chatRoom.sessionsMu.Lock()
existingSession := chatRoom.sessions[username]
chatRoom.sessionsMu.Unlock()
if existingSession != nil {
token := existingSession.ReconnectToken
msg := fmt.Sprintf("Tip: Save this token: %s\n", token)
msg += fmt.Sprintf("To reconnect: reconnect:%s:%s\n", username, token)
conn.Write([]byte(msg))
} else {
session := chatRoom.createSession(username)
token := session.ReconnectToken
msg := fmt.Sprintf("Your token: %s\n", token)
msg += fmt.Sprintf("To reconnect: reconnect:%s:%s\n", username, token)
conn.Write([]byte(msg))
}
}
// Create client object
client := &Client{
conn: conn,
username: username,
outgoing: make(chan string, 10), // Buffered
lastActive: time.Now(),
reconnectToken: reconnectToken,
isSlowClient: rand.Float64() < 0.1, // 10% chance for testing
}
// Clear timeout for normal operation
conn.SetReadDeadline(time.Time{})
// Notify chatroom
chatRoom.join <- client
// Send welcome message
welcomeMsg := buildWelcomeMessage(username)
conn.Write([]byte(welcomeMsg))
// Start read/write loops
go readMessages(client, chatRoom)
writeMessages(client) // Blocks until disconnect
// Update session on disconnect
chatRoom.updateSessionActivity(username)
chatRoom.leave <- client
}
func buildWelcomeMessage(username string) string {
msg := fmt.Sprintf("Welcome, %s!\n", username)
msg += "Commands:\n"
msg += " /users - List all users\n"
msg += " /history [N] - Show last N messages\n"
msg += " /msg <user> <msg> - Private message\n"
msg += " /token - Show your reconnect token\n"
msg += " /stats - Show your stats\n"
msg += " /quit - Leave\n"
return msg
}
The initial 30-second timeout prevents connection exhaustion by disconnecting clients who don't enter a username quickly. The buffered outgoing channel prevents slow clients from blocking the broadcaster. Token-based reconnection lets users resume their session without complex authentication. The dual goroutine design means reading and writing happen independently, so a slow write doesn't block incoming messages.
Add the readMessages() goroutine to handles all incoming data:
func readMessages(client *Client, chatRoom *ChatRoom) {
defer func() {
if r := recover(); r != nil {
fmt.Printf("Panic in readMessages for %s: %v\n", client.username, r)
}
}()
reader := bufio.NewReader(client.conn)
for {
// Set 5-minute idle timeout
client.conn.SetReadDeadline(time.Now().Add(5 * time.Minute))
message, err := reader.ReadString('\n')
if err != nil {
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
fmt.Printf("%s timed out\n", client.username)
} else {
fmt.Printf("%s disconnected: %v\n", client.username, err)
}
return
}
client.markActive() // Update activity timestamp
message = strings.TrimSpace(message)
if message == "" {
continue
}
client.mu.Lock()
client.messagesRecv++
client.mu.Unlock()
// Process commands vs. regular messages
if strings.HasPrefix(message, "/") {
handleCommand(client, chatRoom, message)
continue
}
// Regular message - format and broadcast
formatted := fmt.Sprintf("[%s]: %s\n", client.username, message)
chatRoom.broadcast <- formatted
}
}
5 minutes of idle time triggers auto-disconnect. This prevents zombie connections from consuming resources.
Add the writeMessages() function to drain the client's outgoing channel:
func writeMessages(client *Client) {
defer func() {
if r := recover(); r != nil {
fmt.Printf("Panic in writeMessages for %s: %v\n", client.username, r)
}
}()
writer := bufio.NewWriter(client.conn)
for message := range client.outgoing {
// Simulate slow client (testing mode)
if client.isSlowClient {
time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
}
_, err := writer.WriteString(message)
if err != nil {
fmt.Printf("Write error for %s: %v\n", client.username, err)
return
}
err = writer.Flush()
if err != nil {
fmt.Printf("Flush error for %s: %v\n", client.username, err)
return
}
}
}
Real-world clients have varying network speeds. A client with a slow internet connection shouldn't block message delivery to other users. This is a fundamental challenge in any system that broadcasts to multiple recipients.
To handle this, we use two techniques. First, the outgoing channel is buffered with a size of 10. This means the system can queue up 10 messages for a client without blocking. If a client temporarily slows down (maybe they're loading a large webpage in another tab), the buffer absorbs the slowdown.
Second, when broadcasting messages (which you'll see in the next section), we use non-blocking sends. If a client's buffer is full because they're consistently too slow, we skip sending to them rather than blocking everyone else. The slow client misses some messages, but everyone else continues normally. This is called graceful degradation: the system continues working even when parts of it have problems.
With client connections handled, the next step is implementing the core feature of any chat system: broadcasting messages to all connected users. Broadcasting means taking one message and sending it to many recipients efficiently and safely.
Broadcasting is the heart of a chat application. When one user sends a message, it needs to reach everyone else instantly. But this is trickier than it sounds because you need to persist the message for durability, send it to clients at different speeds without blocking, and maintain message ordering across all clients.
Create internal/chatroom/handlers.go to handle events.
The handleBroadcast() method is where messages reach all users:
package chatroom
import (
"fmt"
"strings"
"time"
)
func (cr *ChatRoom) handleBroadcast(message string) {
// Parse message metadata
parts := strings.SplitN(message, ": ", 2)
from := "system"
actualContent := message
if len(parts) == 2 {
from = strings.Trim(parts[0], "[]")
actualContent = parts[1]
}
// Create persistent message record
cr.messageMu.Lock()
msg := Message{
ID: cr.nextMessageID,
From: from,
Content: actualContent,
Timestamp: time.Now(),
Channel: "global",
}
cr.nextMessageID++
cr.messages = append(cr.messages, msg)
cr.messageMu.Unlock()
// Persist to WAL
if err := cr.persistMessage(msg); err != nil {
fmt.Printf("Failed to persist: %v\n", err)
// Continue anyway - availability over consistency
}
// Collect current clients
cr.mu.Lock()
clients := make([]*Client, 0, len(cr.clients))
for client := range cr.clients {
clients = append(clients, client)
}
cr.totalMessages++
cr.mu.Unlock()
fmt.Printf("Broadcasting to %d clients: %s", len(clients), message)
// Fan-out to all clients
for _, client := range clients {
select {
case client.outgoing <- message:
client.mu.Lock()
client.messagesSent++
client.mu.Unlock()
default:
fmt.Printf("Skipped %s (channel full)\n", client.username)
}
}
}
If a WAL write fails, you still broadcast the message. Why? Because availability is more important than perfect consistency for a chat application. Users get their messages immediately, and you can handle WAL repair manually if needed.
Add these handlers to handlers.go:
func (cr *ChatRoom) handleJoin(client *Client) {
cr.mu.Lock()
cr.clients[client] = true
cr.mu.Unlock()
client.markActive()
fmt.Printf("%s joined (total: %d)\n", client.username, len(cr.clients))
cr.sendHistory(client, 10)
announcement := fmt.Sprintf("*** %s joined the chat ***\n", client.username)
cr.handleBroadcast(announcement)
}
func (cr *ChatRoom) handleLeave(client *Client) {
cr.mu.Lock()
if !cr.clients[client] {
cr.mu.Unlock()
return
}
delete(cr.clients, client)
cr.mu.Unlock()
fmt.Printf("%s left (total: %d)\n", client.username, len(cr.clients))
// Close channel safely
select {
case <-client.outgoing:
// Already closed
default:
close(client.outgoing)
}
announcement := fmt.Sprintf("*** %s left the chat ***\n", client.username)
cr.handleBroadcast(announcement)
}
The handleJoin function adds the client to the active clients map, marks them as active for idle tracking, sends them the last 10 messages so they can see recent conversation, and broadcasts an announcement so everyone knows they joined.
The handleLeave function removes the client from the map, closes their outgoing channel safely (the select checks if it's already closed to avoid a panic), and broadcasts a departure announcement.
Add these helper functions to handlers.go:
func (cr *ChatRoom) sendHistory(client *Client, count int) {
cr.messageMu.Lock()
defer cr.messageMu.Unlock()
start := len(cr.messages) - count
if start < 0 {
start = 0
}
historyMsg := "Recent messages:\n"
for i := start; i < len(cr.messages); i++ {
msg := cr.messages[i]
historyMsg += fmt.Sprintf(" [%s]: %s\n", msg.From, msg.Content)
}
select {
case client.outgoing <- historyMsg:
default:
}
}
func (cr *ChatRoom) sendUserList(client *Client) {
cr.mu.Lock()
defer cr.mu.Unlock()
list := "Users online:\n"
for c := range cr.clients {
status := ""
if c.isInactive(1 * time.Minute) {
status = " (idle)"
}
list += fmt.Sprintf(" - %s%s\n", c.username, status)
}
list += fmt.Sprintf("\nTotal messages: %d\n", cr.totalMessages)
list += fmt.Sprintf("Uptime: %s\n", time.Since(cr.startTime).Round(time.Second))
select {
case client.outgoing <- list:
default:
}
}
func (cr *ChatRoom) handleDirectMessage(dm DirectMessage) {
select {
case dm.toClient.outgoing <- dm.message:
dm.toClient.mu.Lock()
dm.toClient.messagesSent++
dm.toClient.mu.Unlock()
default:
fmt.Printf("Couldn't deliver DM to %s\n", dm.toClient.username)
}
}
func (cr *ChatRoom) findClientByUsername(username string) *Client {
cr.mu.Lock()
defer cr.mu.Unlock()
for client := range cr.clients {
if client.username == username {
return client
}
}
return nil
}
func (c *Client) markActive() {
c.mu.Lock()
defer c.mu.Unlock()
c.lastActive = time.Now()
}
func (c *Client) isInactive(timeout time.Duration) bool {
c.mu.Lock()
defer c.mu.Unlock()
return time.Since(c.lastActive) > timeout
}
You now have a working chat system where clients can connect and exchange messages.
But there's a critical problem: if the server crashes or restarts, all messages are lost. The next step is adding persistence so messages survive failures.
Persistence ensures your chat history survives server crashes and restarts. Without it, users would lose all their conversations every time the server goes down.
You'll implement this using two complementary mechanisms: a write-ahead log for immediate durability and snapshots for fast recovery.
Create internal/chatroom/persistence.go to handle data durability.
The WAL ensures messages survive crashes:
package chatroom
import (
"bufio"
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
)
func (cr *ChatRoom) initializePersistence() error {
if err := os.MkdirAll(cr.dataDir, 0755); err != nil {
return fmt.Errorf("create data dir: %w", err)
}
walPath := filepath.Join(cr.dataDir, "messages.wal")
if err := cr.recoverFromWAL(walPath); err != nil {
fmt.Printf("Recovery failed: %v\n", err)
}
file, err := os.OpenFile(walPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return fmt.Errorf("open wal: %w", err)
}
cr.walFile = file
fmt.Printf("WAL initialized: %s\n", walPath)
return nil
}
func (cr *ChatRoom) recoverFromWAL(walPath string) error {
file, err := os.Open(walPath)
if err != nil {
if os.IsNotExist(err) {
fmt.Println("No WAL found (fresh start)")
return nil
}
return err
}
defer file.Close()
scanner := bufio.NewScanner(file)
recovered := 0
for scanner.Scan() {
line := scanner.Text()
if line == "" {
continue
}
var msg Message
if err := json.Unmarshal([]byte(line), &msg); err != nil {
fmt.Printf("Skipping corrupt line: %s\n", line)
continue
}
cr.messages = append(cr.messages, msg)
if msg.ID >= cr.nextMessageID {
cr.nextMessageID = msg.ID + 1
}
recovered++
}
fmt.Printf("Recovered %d messages\n", recovered)
return nil
}
func (cr *ChatRoom) persistMessage(msg Message) error {
cr.walMu.Lock()
defer cr.walMu.Unlock()
data, err := json.Marshal(msg)
if err != nil {
return err
}
_, err = cr.walFile.Write(append(data, '\n'))
if err != nil {
return err
}
return cr.walFile.Sync()
}
Each line is a JSON-encoded message:
{"id":1,"from":"Alice","content":"Hello world","timestamp":"2024-02-06T10:00:00Z","channel":"global"}
{"id":2,"from":"Bob","content":"Hi Alice!","timestamp":"2024-02-06T10:00:05Z","channel":"global"}
The Sync() call is critical for durability. Without it, the OS might buffer writes in memory, losing them on a crash. The trade-off is that Sync() is expensive (about 1-10ms per call). Production systems might batch multiple messages to improve throughput.
Add snapshot functionality to persistence.go:
func (cr *ChatRoom) createSnapshot() error {
snapshotPath := filepath.Join(cr.dataDir, "snapshot.json")
tempPath := snapshotPath + ".tmp"
file, err := os.Create(tempPath)
if err != nil {
return err
}
defer file.Close()
cr.messageMu.Lock()
data, err := json.MarshalIndent(cr.messages, "", " ")
cr.messageMu.Unlock()
if err != nil {
return err
}
if _, err := file.Write(data); err != nil {
return err
}
if err := file.Sync(); err != nil {
return err
}
file.Close()
if err := os.Rename(tempPath, snapshotPath); err != nil {
return err
}
fmt.Printf("Snapshot created (%d messages)\n", len(cr.messages))
return cr.truncateWAL()
}
func (cr *ChatRoom) truncateWAL() error {
cr.walMu.Lock()
defer cr.walMu.Unlock()
if cr.walFile != nil {
cr.walFile.Close()
}
walPath := filepath.Join(cr.dataDir, "messages.wal")
file, err := os.OpenFile(walPath, os.O_TRUNC|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return err
}
cr.walFile = file
fmt.Println("WAL truncated")
return nil
}
func (cr *ChatRoom) loadSnapshot() error {
snapshotPath := filepath.Join(cr.dataDir, "snapshot.json")
file, err := os.Open(snapshotPath)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
defer file.Close()
data, err := io.ReadAll(file)
if err != nil {
return err
}
cr.messageMu.Lock()
err = json.Unmarshal(data, &cr.messages)
cr.messageMu.Unlock()
if err != nil {
return err
}
for _, msg := range cr.messages {
if msg.ID >= cr.nextMessageID {
cr.nextMessageID = msg.ID + 1
}
}
fmt.Printf("Loaded %d messages from snapshot\n", len(cr.messages))
return nil
}
Writing to .tmp then renaming ensures you never have a half-written snapshot. Even if power fails mid-write, the old snapshot remains valid.
When the server starts, it first loads the snapshot if it exists, which might contain 100K messages and takes about 100ms. Then it replays WAL entries written since the snapshot, which might be only recent messages. Total recovery time is seconds instead of minutes.
With persistence in place, your messages are safe. But network connections are unreliable. Users get disconnected when their WiFi drops, their phone switches towers, or their laptop goes to sleep. The next step is implementing session management so users can reconnect without losing their identity or chat history.
Session management lets users reconnect to your server after network interruptions without needing to create a new account or re-enter credentials. You'll implement this using cryptographically secure tokens that persist across connections.
Create internal/chatroom/session.go for reconnection handling.
package chatroom
import (
"fmt"
"time"
"github.com/yourusername/chatroom/pkg/token"
)
func (cr *ChatRoom) createSession(username string) *SessionInfo {
cr.sessionsMu.Lock()
defer cr.sessionsMu.Unlock()
tok := token.GenerateToken()
session := &SessionInfo{
Username: username,
ReconnectToken: tok,
LastSeen: time.Now(),
CreatedAt: time.Now(),
}
cr.sessions[username] = session
fmt.Printf("Created session for %s (token: %s...)\n", username, tok[:8])
return session
}
func (cr *ChatRoom) validateReconnectToken(username, token string) bool {
cr.sessionsMu.Lock()
defer cr.sessionsMu.Unlock()
session, exists := cr.sessions[username]
if !exists {
return false
}
if session.ReconnectToken != token {
return false
}
if time.Since(session.LastSeen) > 1*time.Hour {
delete(cr.sessions, username)
return false
}
session.LastSeen = time.Now()
return true
}
func (cr *ChatRoom) updateSessionActivity(username string) {
cr.sessionsMu.Lock()
defer cr.sessionsMu.Unlock()
if session, exists := cr.sessions[username]; exists {
session.LastSeen = time.Now()
}
}
func (cr *ChatRoom) isUsernameConnected(username string) bool {
cr.mu.Lock()
defer cr.mu.Unlock()
for client := range cr.clients {
if client.username == username {
return true
}
}
return false
}
func (cr *ChatRoom) cleanupInactiveClients() {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
for range ticker.C {
cr.mu.Lock()
var toRemove []*Client
for client := range cr.clients {
if client.isInactive(5 * time.Minute) {
fmt.Printf("Removing inactive: %s\n", client.username)
toRemove = append(toRemove, client)
}
}
cr.mu.Unlock()
for _, client := range toRemove {
cr.leave <- client
}
}
}
Create pkg/token/token.go for token generation:
package token
import (
"crypto/rand"
"encoding/hex"
)
// GenerateToken returns a secure random 16-byte hex token
func GenerateToken() string {
b := make([]byte, 16)
_, _ = rand.Read(b)
return hex.EncodeToString(b)
}
Tokens here are transmitted in plaintext over TCP. For production use, you should use TLS encryption to protect tokens in transit, hash tokens before storage so a database breach doesn't expose them, and implement rate limiting on reconnection attempts to prevent brute force attacks.
Your chatroom now supports basic messaging and reconnection. But users need ways to interact with the system beyond just sending messages. The command system provides features like listing users, viewing history, and sending private messages.
Commands are messages that start with a forward slash and perform special actions instead of being broadcast to everyone. This is a pattern used by many chat applications like Slack and Discord. You'll implement several useful commands that enhance the user experience.
Add command handling to io.go:
func handleCommand(client *Client, chatRoom *ChatRoom, command string) {
parts := strings.Fields(command)
if len(parts) == 0 {
return
}
switch parts[0] {
case "/users":
chatRoom.listUsers <- client
case "/stats":
client.mu.Lock()
stats := fmt.Sprintf("Your Stats:\n")
stats += fmt.Sprintf(" Messages sent: %d\n", client.messagesSent)
stats += fmt.Sprintf(" Messages received: %d\n", client.messagesRecv)
stats += fmt.Sprintf(" Last active: %s ago\n",
time.Since(client.lastActive).Round(time.Second))
client.mu.Unlock()
select {
case client.outgoing <- stats:
default:
}
case "/msg":
if len(parts) < 3 {
select {
case client.outgoing <- "Usage: /msg <username> <message>\n":
default:
}
return
}
targetUsername := parts[1]
messageText := strings.Join(parts[2:], " ")
targetClient := chatRoom.findClientByUsername(targetUsername)
if targetClient == nil {
select {
case client.outgoing <- fmt.Sprintf("User '%s' not found\n", targetUsername):
default:
}
return
}
privateMsg := fmt.Sprintf("[From %s]: %s\n", client.username, messageText)
select {
case targetClient.outgoing <- privateMsg:
default:
select {
case client.outgoing <- fmt.Sprintf("%s's inbox is full\n", targetUsername):
default:
}
return
}
select {
case client.outgoing <- fmt.Sprintf("Message sent to %s\n", targetUsername):
default:
}
case "/history":
count := 20
if len(parts) > 1 {
fmt.Sscanf(parts[1], "%d", &count)
}
if count > 100 {
count = 100
}
cr.sendHistory(client, count)
case "/token":
chatRoom.sessionsMu.Lock()
session := chatRoom.sessions[client.username]
chatRoom.sessionsMu.Unlock()
if session != nil {
msg := fmt.Sprintf("Your reconnect token:\n")
msg += fmt.Sprintf(" reconnect:%s:%s\n", client.username, session.ReconnectToken)
select {
case client.outgoing <- msg:
default:
}
}
case "/quit":
announcement := fmt.Sprintf("%s left the chat\n", client.username)
chatRoom.broadcast <- announcement
select {
case client.outgoing <- "Goodbye!\n":
default:
}
time.Sleep(100 * time.Millisecond)
client.conn.Close()
default:
select {
case client.outgoing <- fmt.Sprintf("Unknown: %s\n", parts[0]):
default:
}
}
}
Your server is now complete with all the core features: connection handling, message broadcasting, persistence, session management, and commands. But to actually use your chatroom, you need a client application. The client is much simpler than the server because it just needs to connect and relay messages.
The client application provides the user interface for your chatroom. It connects to the server, displays incoming messages, and sends outgoing messages typed by the user. While the server is complex with many concurrent components, the client is straightforward
Create internal/chatroom/client.go for the client implementation.
package chatroom
import (
"bufio"
"fmt"
"net"
"os"
"strings"
)
func StartClient() {
conn, err := net.Dial("tcp", ":9000")
if err != nil {
fmt.Println("Error connecting:", err)
return
}
defer conn.Close()
fmt.Println("Connected to chat server")
// Background goroutine: read from server
go func() {
reader := bufio.NewReader(conn)
for {
message, err := reader.ReadString('\n')
if err != nil {
fmt.Println("Disconnected from server.")
os.Exit(0)
}
// Clear current prompt line...
La portavoz de la Oficina del Alto Comisionado para los Derechos Humanos de la ONU denuncia que EEUU "incumple con la Carta de Derechos Humanos" con su bloqueo a la isla
Nydia Velázquez, congresista demócrata: “EEUU está tratando de matar de hambre a los cubanos hasta que se rindan”
Nueva denuncia de Naciones Unidas al bloqueo redoblado de EEUU a Cuba. La oficina del alto comisionado para los Derechos Humanos de la ONU ha expresado este viernes su “preocupación por la profundización de la crisis socioeconómica de Cuba, en medio de décadas de embargo financiero y comercial, fenómenos meteorológicos extremos y las recientes medidas estadounidenses que restringen los envíos de petróleo. Esto está teniendo un impacto cada vez más grave en los derechos humanos de la población cubana”.
“Los objetivos políticos no pueden justificar acciones que en sí mismas violan los derechos humanos”, afirma el alto comisionado de la ONU para los derechos humanos, Volker Türk, en un llamamiento a levantar “las medidas sectoriales unilaterales, dado su impacto amplio e indiscriminado en la población”.
De acuerdo con la portavoz de la oficina del alto comisionado, Marta Hurtado, “dada la dependencia de los sistemas de salud, alimentación y agua de la importación de combustibles fósiles, la actual escasez de petróleo ha puesto en riesgo la disponibilidad de servicios esenciales en todo el país. Las unidades de cuidados intensivos y las salas de urgencias se encuentran en riesgo, al igual que la producción, el suministro y el almacenamiento de vacunas, hemoderivados y otros medicamentos sensibles a la temperatura”.
Según los datos del organismo, “en Cuba, más del 80% de los equipos de bombeo de agua dependen de la electricidad, y los cortes de electricidad están socavando el acceso al agua potable, el saneamiento y la higiene. La escasez de combustible ha interrumpido el sistema de racionamiento y la canasta básica regulada de alimentos, y ha afectado a las redes de protección social (comida escolar, hogares maternos y residencias de ancianos), afectando de manera desproporcionada a los grupos más vulnerables. Los cortes de electricidad también afectan las comunicaciones y el acceso a la información”.
“Este tipo de sanciones sectoriales afectan a los más vulnerables, no son efectivas y no cumplen ni con la Carta de Naciones Unidas ni con el derecho internacional porque las sanciones deben ser impuestas por el Consejo de Seguridad (de la ONU), no por un país”, afirma la portavoz del organismo, Marta Hurtado, en declaraciones a Efe.
Según la oficina de derechos humanos, “el acceso a bienes y servicios esenciales, como alimentos, agua, medicamentos, combustible y electricidad adecuados, debe garantizarse siempre, ya que son fundamentales en las sociedades modernas para el derecho a la vida y el disfrute de muchos otros derechos. El impacto prolongado y sostenido de las sanciones sectoriales genera dificultades económicas y debilita la capacidad del Estado para cumplir con sus responsabilidades fundamentales, como la prestación de servicios de protección y asistencia. Esto aumenta el riesgo de agravar la disrupción social en Cuba”.
“El Estado, por su parte”, dice la oficina de derechos humanos, “debe asegurarse de estar preparado para responder de conformidad con el derecho internacional de los derechos humanos, prestando atención a las necesidades de los más vulnerables y priorizando la mediación, la desescalada y la salvaguardia del derecho a la libertad de reunión pacífica y de expresión para todos”.
