<div class="biostories_showcase section"><div class="center-align"><label>5 <a href="biohistorias">Biohistorias</a></label></div><div class="masonry"><div class="masonry-item" tabindex="0"><a href="biohistorias?id=157" title="¿Es posible una soberanía alimentaria?"><img data-id="3266" data-src="https://revistabioika.org/assets/multimedia/docs/es/social/aleja.velez@revistabioika.org/thumbs/20210529124118-post-lector-escribe-rossember-s.png" alt="" class="responsive-img hoverable media_observer"></a><div class="center-align"><label>¿Es posible una soberanía alimentaria?</label></div></div><div class="masonry-item" tabindex="0"><a href="biohistorias?id=85" title="Biodiversidad: la vida en sus diferentes formas"><img data-id="2339" data-src="https://revistabioika.org/assets/multimedia/docs/pt/artes/anielly.oliveira@revistabioika.org/thumbs/20200917080049-imagem-1-s.jpg" alt="Reserva Forestal Adolpho Ducke, en Manaus, Brasil" class="responsive-img hoverable media_observer"></a><div class="center-align"><label>Biodiversidad: la vida en sus diferentes formas</label></div></div><div class="masonry-item" tabindex="0"><a href="biohistorias?id=464" title="Recomendaciones y fuentes de información confiables sobre el coronavirus (COVID-19) para América Latina"><img data-id="1563" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/david.gonzalez@revistabioika.org/thumbs/20200324235204-poster-covid19-es-s.png" alt="Afiche sobre síntomas y cuidados del coronavirus (españool)" class="responsive-img hoverable media_observer"></a><div class="center-align"><label>Recomendaciones y fuentes de información confiables sobre el coronavirus (COVID-19) para América Latina</label></div></div><div class="masonry-item" tabindex="0"><a href="biohistorias?id=187" title="Ciencia, divulgación científica y algas en Paraguay"><div class="video-container"><button class="play" aria-label="Play"></button><img class="cover" loading="lazy" alt="Video" src="https://img.youtube.com/vi_webp/jEK68SiEmBs/sddefault.webp"><iframe data-id="3261" data-src="https://www.youtube.com/embed/jEK68SiEmBs" class="hoverable" width="853" height="480" frameborder="0" allowfullscreen="" title="Video: Entrevista a Melissa dos Santos">Video: Entrevista a Melissa dos Santos</iframe></div><a href="biohistorias?id=187" class="btn biohistorias-bg masonry-full" title="Video: Entrevista a Melissa dos Santos">Ver</a></a><div class="center-align"><label>Ciencia, divulgación científica y algas en Paraguay</label></div></div><div class="masonry-item" tabindex="0"><a href="biohistorias?id=386" title="Relación entre el cambio de cobertura del suelo y los fuegos ocasionados en la serranía de La Lindosa en San José del Guaviare"><img data-id="4340" data-src="https://revistabioika.org/assets/multimedia/docs/pt/social/editorial@revistabioika.org/thumbs/20231105193846-econoticias-lindosa-diana-monroy-ed-4-es-s.png" alt="Post: Relación entre el cambio de cobertura del suelo y los fuegos ocasionados en la serranía de La Lindosa en San José del Guaviare" class="responsive-img hoverable media_observer"></a><div class="center-align"><label>Relación entre el cambio de cobertura del suelo y los fuegos ocasionados en la serranía de La Lindosa en San José del Guaviare</label></div></div></div></div><div class="row container">
			  <div class="card" id="palabra-de-especialista_146">
				  <div class="col s12 l6 center-align"><div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/palabra-de-especialista/post?id=146"><img src="https://revistabioika.org/assets/multimedia/users/staff/thumbs/20240112112511-design-1704503377792-m.jpg" alt="Los ambientes de agua dulce se caracterizan por tener una gran cantidad de especies. Ilustración con collage imaginario que representa la gran diversidad de especies de peces y otros animales acuáticos. "></a>
		<a href="https://revistabioika.org/es/palabra-de-especialista" class="card-title especialista-bg hoverable"><i class="material-icons left especialista-icon-s-white icontiny tiny"></i>Palabra de especialista</a></div>

</div>
				<div class="col s12 l6"><div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=10">Ed. 10</a> / Tema: Políticas públicas, biodiversidad y conservación vol 2.</label><h1><a href="https://revistabioika.org/es/palabra-de-especialista/post?id=146">La fluctuación del mar y su efecto en la biodiversidad en ambientes de agua dulce</a></h1><p>Para entender la biodiversidad actual, es esencial explorar más allá de los factores ecológicos actuales y sumergirse en la historia evolutiva de los organismos, revelando cómo las variaciones en el nivel del mar pueden haber influido en la diversidad de peces en entornos costeros continentales a lo largo del tiempo.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=246">Juliana Rosa Matias Ciccheto</a>, <a href="https://revistabioika.org/es/bio?idauthor=247">Walter Antonio Pereira Boeger</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/palabra-de-especialista/post?id=146&title=La fluctuación del mar y su efecto en la biodiversidad en ambientes de agua dulce&label=Juliana Rosa Matias Ciccheto, Walter Antonio Pereira Boeger&bgclass=especialista-bg&iconclass=especialista-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>

</div><!--social links-->
			</div>
		</div>
		<div id="palabra-de-especialista_146-extra" class="hide"><div class="center-align"></div></div>
		<!--social links-->
		<div class="section">
			<div class="shareaholic-canvas" data-app="follow_buttons" data-app-id="26832927"></div>
		</div><div class="row container"><div class="col s12 m6 l4"><div class="card" id="el-lector-escribe_145">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/el-lector-escribe/post?id=145"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/pt/artes/anielly.oliveira@revistabioika.org/20231220115042-polinizacion.png" alt="Transferencia de polen desde las anteras (parte masculina) y el estigma (parte femenina) entre las flores del maracuyá (Passiflora alata) realizada por abejas del género Xylocopa"></a>
		<a href="https://revistabioika.org/es/el-lector-escribe" class="card-title lesc-bg hoverable"><i class="material-icons left lesc-icon-s-white icontiny tiny"></i>El lector escribe</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=10">Ed. 10</a> / Tema: Políticas públicas, biodiversidad y conservación vol 2.</label><h1><a href="https://revistabioika.org/es/el-lector-escribe/post?id=145">Biodiversidad en la mesa: el valor de la polinización para la vida</a></h1><p>La polinización es uno de los principales servicios ecosistémicos responsables del bienestar y la salud humana, incluida nuestra seguridad alimentaria. Diversos animales participan en este proceso, entre ellos abejas, mariposas, aves y murciélagos. Esta es otra razón para preservar la biodiversidad y reconsiderar nuestros métodos de cultivo en busca de una agricultura más sustentable.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=245">Laryssa Negri Peres</a>, <a href="https://revistabioika.org/es/bio?idauthor=83">Isabela Galarda Varassin</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/el-lector-escribe/post?id=145&title=Biodiversidad en la mesa: el valor de la polinización para la vida&label=Laryssa Negri Peres, Isabela Galarda Varassin&bgclass=lesc-bg&iconclass=lesc-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="el-lector-escribe_145-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 m6 l4"><div class="card" id="el-lector-escribe_143">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/el-lector-escribe/post?id=143"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/david.gonzalez@revistabioika.org/thumbs/20231114011957-puesto-de-verduras-agroecologicas-en-ciudad-de-santa-fe-m.jpg" alt="Puesto de verduras agroecológicas en la feria de plaza Pueyrredón en ciudad de Santa Fe, Argentina, organizada por el consorcio de productores y productoras La Verdecita."></a>
		<a href="https://revistabioika.org/es/el-lector-escribe" class="card-title lesc-bg hoverable"><i class="material-icons left lesc-icon-s-white icontiny tiny"></i>El lector escribe</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=10">Ed. 10</a> / Tema: Políticas públicas, biodiversidad y conservación vol 2.</label><h1><a href="https://revistabioika.org/es/el-lector-escribe/post?id=143">Carta abierta a los agricultores</a></h1><p>Una inspiradora invitación con diversas estrategias y prácticas sostenibles para combinar conservación y agricultura.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=216">Anielly Oliveira</a>, <a href="https://revistabioika.org/es/bio?idauthor=239">Aline Rosado</a>, <a href="https://revistabioika.org/es/bio?idauthor=240">ÉLida Gouveia</a>, <a href="https://revistabioika.org/es/bio?idauthor=241">Mayara Passere</a>, <a href="https://revistabioika.org/es/bio?idauthor=5">Rosa Maria Dias</a>, <a href="https://revistabioika.org/es/bio?idauthor=242">Vinícius Rasvailer</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/el-lector-escribe/post?id=143&title=Carta abierta a los agricultores&label=Anielly Oliveira, Aline Rosado, ÉLida Gouveia, Mayara Passere, Rosa Maria Dias, Vinícius Rasvailer&bgclass=lesc-bg&iconclass=lesc-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="el-lector-escribe_143-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 l4"><h3 class="center-align"><label>Post (10)</label><br><i class="material-icons">notifications_none</i> Recientes</h3><div class="card-panel"><div class="postList"><ul class="collection"><li class="collection-item"><i class="material-icons especialista-icon-s-color iconsmall" title="Palabra de especialista"></i> <a href="https://revistabioika.org/es/palabra-de-especialista/post?id=146" class="Recientes">La fluctuación del mar y su efecto en la biodiversidad en ambientes de agua dulce</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=246">Juliana Rosa Matias Ciccheto</a>, <a href="https://revistabioika.org/es/bio?idauthor=247">Walter Antonio Pereira Boeger</a></label></li><li class="collection-item"><i class="material-icons lesc-icon-s-color iconsmall" title="El lector escribe"></i> <a href="https://revistabioika.org/es/el-lector-escribe/post?id=145" class="Recientes">Biodiversidad en la mesa: el valor de la polinización para la vida</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=245">Laryssa Negri Peres</a>, <a href="https://revistabioika.org/es/bio?idauthor=83">Isabela Galarda Varassin</a></label></li><li class="collection-item"><i class="material-icons lesc-icon-s-color iconsmall" title="El lector escribe"></i> <a href="https://revistabioika.org/es/el-lector-escribe/post?id=143" class="Recientes">Carta abierta a los agricultores</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=216">Anielly Oliveira</a>, <a href="https://revistabioika.org/es/bio?idauthor=239">Aline Rosado</a>, <a href="https://revistabioika.org/es/bio?idauthor=240">ÉLida Gouveia</a>, <a href="https://revistabioika.org/es/bio?idauthor=241">Mayara Passere</a>, <a href="https://revistabioika.org/es/bio?idauthor=5">Rosa Maria Dias</a>, <a href="https://revistabioika.org/es/bio?idauthor=242">Vinícius Rasvailer</a></label></li><li class="collection-item"><i class="material-icons ecoando-icon-s-color iconsmall" title="Ecoando"></i> <a href="https://revistabioika.org/es/ecoando/post?id=141" class="Recientes">El baile de las sillas entre parásitos y sus hospederos</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=229">Elvira  D’bastiani</a>, <a href="https://revistabioika.org/es/bio?idauthor=231">Débora  Princepe</a>, <a href="https://revistabioika.org/es/bio?idauthor=230">Sabrina  Borges Lino Araujo</a>, <a href="https://revistabioika.org/es/bio?idauthor=232">Karla  Magalhães Campião</a></label></li><li class="collection-item"><i class="material-icons transformando-icon-s-color iconsmall" title="Transformando el mundo"></i> <a href="https://revistabioika.org/es/transformando-el-mundo/post?id=142" class="Recientes">Muestras científicas para la socialización del conocimiento de Investigaciones ecológicas de larga duración en la planicie de inundación del alto río Paraná</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=46">Yasmin Rodrigues De Souza</a>, <a href="https://revistabioika.org/es/bio?idauthor=235">Beatriz Melissa Campos</a>, <a href="https://revistabioika.org/es/bio?idauthor=234">João Vitor Da Silva</a>, <a href="https://revistabioika.org/es/bio?idauthor=233">Louzi Magalhães</a>, <a href="https://revistabioika.org/es/bio?idauthor=236">Marina Santos</a>, <a href="https://revistabioika.org/es/bio?idauthor=237">Claudia Bonecker</a></label></li><li class="collection-item"><i class="material-icons ecoando-icon-s-color iconsmall" title="Ecoando"></i> <a href="https://revistabioika.org/es/ecoando/post?id=144" class="Recientes">El potencial terapéutico de los aceites naturales: la sostenibilidad en encuentro con la medicina</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=34">Alan Deivid Pereira</a>, <a href="https://revistabioika.org/es/bio?idauthor=120">Adela  Castro</a></label></li><li class="collection-item"><i class="material-icons especialista-icon-s-color iconsmall" title="Palabra de especialista"></i> <a href="https://revistabioika.org/es/palabra-de-especialista/post?id=140" class="Recientes">Reflexiones sobre la alfabetización científica y nuestras decisiones diarias</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=210">Ana María Gómez Villegas</a></label></li><li class="collection-item"><i class="material-icons transformando-icon-s-color iconsmall" title="Transformando el mundo"></i> <a href="https://revistabioika.org/es/transformando-el-mundo/post?id=139" class="Recientes">Cuerpo, sociedad y medio ambiente: las capas de un simple fenómeno natural</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=226">Carolina Pera</a></label></li><li class="collection-item"><i class="material-icons econoticias-icon-s-color iconsmall" title="Econoticias"></i> <a href="https://revistabioika.org/es/econoticias/post?id=138" class="Recientes">El fenómeno “Frailejón Ernesto Pérez”</a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=218">Ángela Liliana Gutiérrez Cortés</a>, <a href="https://revistabioika.org/es/bio?idauthor=219">David Fernando González Tovar</a></label></li><li class="collection-item"><i class="material-icons ecoando-icon-s-color iconsmall" title="Ecoando"></i> <a href="https://revistabioika.org/es/ecoando/post?id=137" class="Recientes">Disminución de la producción pesquera: ¿quién es el verdadero responsable? </a><br><label>Por: <a href="https://revistabioika.org/es/bio?idauthor=218">Ángela Liliana Gutiérrez Cortés</a>, <a href="https://revistabioika.org/es/bio?idauthor=219">David Fernando González Tovar</a></label></li></ul></div></div><p><a href="#newsletter" class="btn editorial-bg"><i class="material-icons left">loyalty</i>Suscríbete gratis</a></p></div></div><div class="row container"><div class="col s12 l10 offset-l1 clearfix"><div class="card" id="ecoando_141">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/ecoando/post?id=141"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/david.gonzalez@revistabioika.org/thumbs/20220605205748-hsi6porciento-m.png" alt="Representación de la relación filogenética de dos especies de roedores con el lobo de crin y dos escenarios hipotéticos de intercambio extremo de huéspedes."></a>
		<a href="https://revistabioika.org/es/ecoando" class="card-title ecoando-bg hoverable"><i class="material-icons left ecoando-icon-s-white icontiny tiny"></i>Ecoando</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=10">Ed. 10</a> / Tema: Políticas públicas, biodiversidad y conservación vol 2.</label><h1><a href="https://revistabioika.org/es/ecoando/post?id=141">El baile de las sillas entre parásitos y sus hospederos</a></h1><p>Desde la reciente pandemia mundial hasta el cambio de hospederos, este estudio revela cómo estos eventos dan forma al panorama de enfermedades, destacando la urgencia de comprender y actuar sobre esta interacción dinámica, en la que la danza evolutiva entre parásitos y hospederos revela secretos cruciales para nuestra salud.​</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=229">Elvira  D’bastiani</a>, <a href="https://revistabioika.org/es/bio?idauthor=231">Débora  Princepe</a>, <a href="https://revistabioika.org/es/bio?idauthor=230">Sabrina  Borges Lino Araujo</a>, <a href="https://revistabioika.org/es/bio?idauthor=232">Karla  Magalhães Campião</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/ecoando/post?id=141&title=El baile de las sillas entre parásitos y sus hospederos&label=Elvira  D’bastiani, Débora  Princepe, Sabrina  Borges Lino Araujo, Karla  Magalhães Campião&bgclass=ecoando-bg&iconclass=ecoando-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="ecoando_141-extra" class="hide"><div class="center-align"></div></div>

</div></div>

</div><div class="row container"><div class="col s12 m6 l4"><div class="card" id="transformando-el-mundo_142">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/transformando-el-mundo/post?id=142"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/alfonso.pineda@revistabioika.org/thumbs/20231209085852-thumb2-m.jpg" alt="Muestras científicas permiten la interacción de científicos con la comuidad local"></a>
		<a href="https://revistabioika.org/es/transformando-el-mundo" class="card-title transformando-bg hoverable"><i class="material-icons left transformando-icon-s-white icontiny tiny"></i>Transformando el mundo</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=10">Ed. 10</a> / Tema: Políticas públicas, biodiversidad y conservación vol 2.</label><h1><a href="https://revistabioika.org/es/transformando-el-mundo/post?id=142">Muestras científicas para la socialización del conocimiento de Investigaciones ecológicas de larga duración en la planicie de inundación del alto río Paraná</a></h1><p>Mostras Científicas pueden ser puentes entre la Academia y la Comunidad. Estos eventos no solo divulgan conocimiento, sino que también fomentan una valiosa interacción entre las instituciones académicas y la comunidad local</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=46">Yasmin Rodrigues De Souza</a>, <a href="https://revistabioika.org/es/bio?idauthor=235">Beatriz Melissa Campos</a>, <a href="https://revistabioika.org/es/bio?idauthor=234">João Vitor Da Silva</a>, <a href="https://revistabioika.org/es/bio?idauthor=233">Louzi Magalhães</a>, <a href="https://revistabioika.org/es/bio?idauthor=236">Marina Santos</a>, <a href="https://revistabioika.org/es/bio?idauthor=237">Claudia Bonecker</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/transformando-el-mundo/post?id=142&title=Muestras científicas para la socialización del conocimiento de Investigaciones ecológicas de larga duración en la planicie de inundación del alto río Paraná&label=Yasmin Rodrigues De Souza, Beatriz Melissa Campos, João Vitor Da Silva, Louzi Magalhães, Marina Santos, Claudia Bonecker&bgclass=transformando-bg&iconclass=transformando-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="transformando-el-mundo_142-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 m6 l4"><div class="card" id="ecoando_144">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/ecoando/post?id=144"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/pt/artes/taise.lopes@revistabioika.org/thumbs/20231211122115-pexels-nikolett-emmert-17497508-m.jpg" alt="Ejemplar de una planta de orégano, utilizada en la producción de aceites esenciales."></a>
		<a href="https://revistabioika.org/es/ecoando" class="card-title ecoando-bg hoverable"><i class="material-icons left ecoando-icon-s-white icontiny tiny"></i>Ecoando</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=10">Ed. 10</a> / Tema: Políticas públicas, biodiversidad y conservación vol 2.</label><h1><a href="https://revistabioika.org/es/ecoando/post?id=144">El potencial terapéutico de los aceites naturales: la sostenibilidad en encuentro con la medicina</a></h1><p>Una muestra de las ventajas de la fitoterapia en la medicina veterinaria, con la producción sostenible de aceite de orégano para el tratamiento de la mastitis bovina, que promueve la salud animal con un impacto positivo en la producción lechera y respeto al medio ambiente.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=34">Alan Deivid Pereira</a>, <a href="https://revistabioika.org/es/bio?idauthor=120">Adela  Castro</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/ecoando/post?id=144&title=El potencial terapéutico de los aceites naturales: la sostenibilidad en encuentro con la medicina&label=Alan Deivid Pereira, Adela  Castro&bgclass=ecoando-bg&iconclass=ecoando-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="ecoando_144-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 l4"><h3 class="center-align"><label>Vídeo</label><br><i class="material-icons">&#xE639;</i> ¡Participa!</h3><div class="video-container"><button class="play" aria-label="Play"></button><img class="cover" loading="lazy" alt="¡Participa!" src="https://img.youtube.com/vi_webp/dyMJUoXwJrw/sddefault.webp"><iframe data-src="https://www.youtube.com/embed/dyMJUoXwJrw?rel=0" width="853" height="480" frameborder="0" allowfullscreen="" title="video">¡Participa!</iframe></div><div class="collection"><a href="https://revistabioika.org/es/cartas" class="collection-item"><i class="material-icons cartas-icon-s-color iconsmall left"></i>Cartas</a> <a href="https://revistabioika.org/es/contribuir" class="collection-item"><i class="material-icons left">crop_original</i>Regala artes</a> <a href="https://revistabioika.org/es/unete" class="collection-item"><i class="material-icons left">content_copy</i>Únete al equipo</a> <a href="https://revistabioika.org/es/someta-sus-propuestas" class="collection-item"><i class="material-icons left">insights</i>Somete tus propuestas</a></div></div></div><div class="row container"><div class="col s12 l10 offset-l1 clearfix"><div class="card" id="palabra-de-especialista_140">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/palabra-de-especialista/post?id=140"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/angela.gutierrez@revistabioika.org/thumbs/20220721102433-supermercado-m.jpg" alt="Diariamente, a sociedade está exposta a uma grande quantidade de informações que determinam seu estilo de vida e bem-estar. Ter o conhecimento básico para interpretar essas informações é essencial para moldar os hábitos de consumo, com base em sua capacidade monetária e impacto ambiental."></a>
		<a href="https://revistabioika.org/es/palabra-de-especialista" class="card-title especialista-bg hoverable"><i class="material-icons left especialista-icon-s-white icontiny tiny"></i>Palabra de especialista</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=9">Ed. 9</a> / Tema: Políticas públicas, biodiversidad y conservación</label><h1><a href="https://revistabioika.org/es/palabra-de-especialista/post?id=140">Reflexiones sobre la alfabetización científica y nuestras decisiones diarias</a></h1><p>¿Cómo se relaciona la enseñanza de las ciencias con el día a día? El conocimiento básico de las ciencias permite la formación de ciudadanos más integrales, críticos y preocupados con sus hábitos de consumo y con el bienestar del planeta.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=210">Ana María Gómez Villegas</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/palabra-de-especialista/post?id=140&title=Reflexiones sobre la alfabetización científica y nuestras decisiones diarias&label=Ana María Gómez Villegas&bgclass=especialista-bg&iconclass=especialista-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="palabra-de-especialista_140-extra" class="hide"><div class="center-align"></div></div>

</div></div>

</div><div class="row container"><div class="col s12 l8"><div class="card" id="transformando-el-mundo_139">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/transformando-el-mundo/post?id=139"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/pt/artes/mirtha.angulo@revistabioika.org/thumbs/20220526142223-fig-3-passando-abs-de-vo-pra-neta-m.jpg" alt="La educación para una menstruación libre de desperdicios puede convertirse en una agenda familiar y escolar para que las personas puedan elegir qué método usar."></a>
		<a href="https://revistabioika.org/es/transformando-el-mundo" class="card-title transformando-bg hoverable"><i class="material-icons left transformando-icon-s-white icontiny tiny"></i>Transformando el mundo</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=9">Ed. 9</a> / Tema: Políticas públicas, biodiversidad y conservación</label><h1><a href="https://revistabioika.org/es/transformando-el-mundo/post?id=139">Cuerpo, sociedad y medio ambiente: las capas de un simple fenómeno natural</a></h1><p>Un enfoque pedagógico de una iniciativa familiar, que además de ofrecer alternativas ecológicas para el manejo del ciclo menstrual, plantea estrategias para reducir desechos, evitar la desinformación y derrumbar tabúes, a partir de soluciones que priorizan el contexto social de las personas.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=226">Carolina Pera</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/transformando-el-mundo/post?id=139&title=Cuerpo, sociedad y medio ambiente: las capas de un simple fenómeno natural&label=Carolina Pera&bgclass=transformando-bg&iconclass=transformando-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="transformando-el-mundo_139-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 l4"><div class="weather"></div></div><div class="col s12 center-align"></div></div><div class="row container"><div class="col s12 m6 l4"><div class="card" id="econoticias_138">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/econoticias/post?id=138"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/somete-tus-propuestas/angela.gutierrez@revistabioika.org/thumbs/20220424212830-frailejon-1223161-1920-m.jpg" alt="Paisaje de páramo. Ecosistema de alta montaña típico de la cordillera de Los Andes, presente principalmente en Colombia, Ecuador y Venezuela, reconocido por su importancia en la producción y acumulación de agua."></a>
		<a href="https://revistabioika.org/es/econoticias" class="card-title econoticias-bg hoverable"><i class="material-icons left econoticias-icon-s-white icontiny tiny"></i>Econoticias</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=9">Ed. 9</a> / Tema: Políticas públicas, biodiversidad y conservación</label><h1><a href="https://revistabioika.org/es/econoticias/post?id=138">El fenómeno “Frailejón Ernesto Pérez”</a></h1><p>Ernesto Pérez, un personaje animado que salta de un programa de televisión infantil al Festival Estéreo Picnic (FEP) divulgando la importancia de cuidar el agua en Colombia.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=218">Ángela Liliana Gutiérrez Cortés</a>, <a href="https://revistabioika.org/es/bio?idauthor=219">David Fernando González Tovar</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/econoticias/post?id=138&title=El fenómeno “Frailejón Ernesto Pérez”&label=Ángela Liliana Gutiérrez Cortés, David Fernando González Tovar&bgclass=econoticias-bg&iconclass=econoticias-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="econoticias_138-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 m6 l4"><div class="card" id="ecoando_137">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/ecoando/post?id=137"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/users/staff/thumbs/20220519203141-rio-magdalena,-colombia-03-m.jpg" alt="Vista del río Magdalena localizado entre los valles de la cordillera de Los Andes y rodeado de imponentes montañas."></a>
		<a href="https://revistabioika.org/es/ecoando" class="card-title ecoando-bg hoverable"><i class="material-icons left ecoando-icon-s-white icontiny tiny"></i>Ecoando</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=9">Ed. 9</a> / Tema: Políticas públicas, biodiversidad y conservación</label><h1><a href="https://revistabioika.org/es/ecoando/post?id=137">Disminución de la producción pesquera: ¿quién es el verdadero responsable? </a></h1><p>Los pescadores han sido señalados por décadas como los causantes de la disminución de la producción pesquera; este trabajo representa un desafío al manejo clásico de las pesquerías, que considera la degradación ambiental como la principal causa de este fenómeno.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=218">Ángela Liliana Gutiérrez Cortés</a>, <a href="https://revistabioika.org/es/bio?idauthor=219">David Fernando González Tovar</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/ecoando/post?id=137&title=Disminución de la producción pesquera: ¿quién es el verdadero responsable? &label=Ángela Liliana Gutiérrez Cortés, David Fernando González Tovar&bgclass=ecoando-bg&iconclass=ecoando-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="ecoando_137-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 l4"><img data-src="https://revistabioika.org/assets/multimedia/interface/covers/editorial-10/cover-ed10-m-es.png" alt="cover" class="responsive-img lazy" loading="lazy"><br><label>Conoce la portada de la 10<sup>a</sup> edición. <a href="https://revistabioika.org/es/portada?ed=10">Ver portada</a></label></div></div><div class="row container"><div class="col s12 l10 offset-l1 clearfix"><div class="card" id="palabra-de-especialista_135">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/palabra-de-especialista/post?id=135"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/david.gonzalez@revistabioika.org/thumbs/20220710145713-brain-4142336-m.jpg" alt="La divulgación científica ocupa un lugar cada vez más importante en la sociedad, pues le proporciona información y conocimientos básicos que la empoderan y la preparan para ejercer control político sobre del manejo de temas de interés colectivo, como el cambio climático y la conservación de los recursos ambientales."></a>
		<a href="https://revistabioika.org/es/palabra-de-especialista" class="card-title especialista-bg hoverable"><i class="material-icons left especialista-icon-s-white icontiny tiny"></i>Palabra de especialista</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=9">Ed. 9</a> / Tema: Políticas públicas, biodiversidad y conservación</label><h1><a href="https://revistabioika.org/es/palabra-de-especialista/post?id=135">La relevancia de la divulgación científica para la educación ambiental: enfrentando a las <em>fake news</em></a></h1><p>El importante papel de la ciencia en la formación de una ciudadanía crítica y capaz de acceder a información verificada, fundamental para enfrentar las discusiones relacionadas con problemáticas como la conservación del medio ambiente y el cambio climático.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=2">Maria das Graças Targino</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/palabra-de-especialista/post?id=135&title=La relevancia de la divulgación científica para la educación ambiental: enfrentando a las <em>fake news</em>&label=Maria das Graças Targino&bgclass=especialista-bg&iconclass=especialista-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="palabra-de-especialista_135-extra" class="hide"><div class="center-align"></div></div>

</div></div>

</div><div class="row container"><div class="col s12 m6 l4"><div class="card" id="el-lector-escribe_134">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/el-lector-escribe/post?id=134"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/angela.gutierrez@revistabioika.org/thumbs/20220422202028-50950543038-3b1762b369-k-m.jpg" alt="<em>Chroococcus</em> es un género de cianobacteria que puede crecer sobre las rocas. Organismos más cercanos a las bacterias que a las algas, han sido por siglos, responsables de la producción de oxígeno a través de la fotosíntesis."></a>
		<a href="https://revistabioika.org/es/el-lector-escribe" class="card-title lesc-bg hoverable"><i class="material-icons left lesc-icon-s-white icontiny tiny"></i>El lector escribe</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=9">Ed. 9</a> / Tema: Políticas públicas, biodiversidad y conservación</label><h1><a href="https://revistabioika.org/es/el-lector-escribe/post?id=134">Cianobacterias, el alfa y omega:  cambiaron nuestra atmósfera y serán las últimas en irse</a></h1><p>Las diminutas cianobacterias transformaron la atmósfera que permitió el florecimiento de la vida que hoy conocemos. Gracias a la liberación de grandes cantidades de oxígeno fue posible la aparición de diferentes formas de vida, muchas de la cuales aún sobreviven.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=214">Alfonso Pineda</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/el-lector-escribe/post?id=134&title=Cianobacterias, el alfa y omega:  cambiaron nuestra atmósfera y serán las últimas en irse&label=Alfonso Pineda&bgclass=lesc-bg&iconclass=lesc-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="el-lector-escribe_134-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 m6 l4"><div class="card" id="ecoando_136">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/ecoando/post?id=136"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/angela.gutierrez@revistabioika.org/thumbs/20220505185654-1.-amazonia-basin-m.jpg" alt="La cuenca del río Amazonas es la más grande del continente americano, reúne a siete países y cubre un área de siete millones de km2. Reconocida por su biodiversidad y su papel fundamental en la regulación del clima de la región, esta cuenca sufre una gran cantidad de amenazas por actividades antrópicas como la deforestación y la minería."></a>
		<a href="https://revistabioika.org/es/ecoando" class="card-title ecoando-bg hoverable"><i class="material-icons left ecoando-icon-s-white icontiny tiny"></i>Ecoando</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=9">Ed. 9</a> / Tema: Políticas públicas, biodiversidad y conservación</label><h1><a href="https://revistabioika.org/es/ecoando/post?id=136">Lo que los ojos no ven, la biodiversidad lo siente: la amenaza de especies exóticas en la Amazonía </a></h1><p>Más de 30 investigadores, con representantes de seis países de América del Sur, coordinados por científicos de la Universidad Federal de Paraná (UFPR), publicaron un estudio revelando cifras alarmantes de la presencia de especies de peces exóticos en la región amazónica, que permitió analizar situación actual de la región, así como el papel de la legislación de cada país con relación a estas especies.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=227">Lais  Carneiro</a>, <a href="https://revistabioika.org/es/bio?idauthor=43">Thiago V. T.  Occhi</a>, <a href="https://revistabioika.org/es/bio?idauthor=106">Larissa Faria</a>, <a href="https://revistabioika.org/es/bio?idauthor=228">Carolina  Rodrigues Da Costa Doria</a>, <a href="https://revistabioika.org/es/bio?idauthor=45">Jean Ricardo  Simões Vitule</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/ecoando/post?id=136&title=Lo que los ojos no ven, la biodiversidad lo siente: la amenaza de especies exóticas en la Amazonía &label=Lais  Carneiro, Thiago V. T.  Occhi, Larissa Faria, Carolina  Rodrigues Da Costa Doria, Jean Ricardo  Simões Vitule&bgclass=ecoando-bg&iconclass=ecoando-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="ecoando_136-extra" class="hide"><div class="center-align"></div></div>

</div></div>

<div class="col s12 l4"><h3 class="center-align"><label>Vídeo</label><br><i class="material-icons">&#xE639;</i> Origen de la Revista Bioika</h3><div class="video-container"><button class="play" aria-label="Play"></button><img class="cover" loading="lazy" alt="Origen de la Revista Bioika" src="https://img.youtube.com/vi_webp/YpJnUvJTw8E/sddefault.webp"><iframe data-src="https://www.youtube.com/embed/YpJnUvJTw8E?rel=0" width="853" height="480" frameborder="0" allowfullscreen="" title="video">Origen de la Revista Bioika</iframe></div><h4 class="center-align"><label>Redes sociales</label><br><i class="material-icons tiny">share</i> <span class="title">Compartir</span> <a href="#!" class="collection-item dropdown-button" data-activates="share_extras"><i class="material-icons">expand_more</i ></a></h4> <div class="shareaholic-canvas" data-app="share_buttons" data-app-id="26790619"></div> <ul id="share_extras" class="dropdown-content"><li><a href="#!print" onclick="window.print();return false;" class="collection-item">Imprimir</a></li></ul></div></div><div class="row container"><div class="col s12 l10 offset-l1 clearfix"><div class="card" id="palabra-de-especialista_133">
<div class="card-image image-16_9">
		<a href="https://revistabioika.org/es/palabra-de-especialista/post?id=133"><img class="lazy" loading="lazy" data-src="https://revistabioika.org/assets/multimedia/docs/es/artes/david.gonzalez@revistabioika.org/thumbs/20211024010940-11265106825-ea46d1014a-o-m.jpg" alt="Muestra del tejido manual tradicional de los Andes peruanos, perteneciente a Awamaki, una organización de mujeres cerca de la ciudad de Ollantaytambo que promueve y conserva el conocimiento textil artesanal."></a>
		<a href="https://revistabioika.org/es/palabra-de-especialista" class="card-title especialista-bg hoverable"><i class="material-icons left especialista-icon-s-white icontiny tiny"></i>Palabra de especialista</a></div>

<div class="card-content"><label><a href="https://revistabioika.org/es/ediciones?ed=8">Ed. 8</a> / Tema: Ciencia y la tecnología para la vida</label><h1><a href="https://revistabioika.org/es/palabra-de-especialista/post?id=133">El aporte de la investigación cultural a la transición sostenible</a></h1><p>Un estudio sobre la industria textil en las regiones euromediterráneas, devela cómo la investigación sobre la cultura puede acelerar los cambios sostenibles ante una crisis medioambiental en un futuro no muy lejano.</p></div>

<div class="card-action"><div class="row">
		<div class="col s11 m10">
<label>Por: <a href="https://revistabioika.org/es/bio?idauthor=201">Óscar Miguel Blanco Sierra</a></label></div>
				<div class="col s1 m2"><span data-url="https://revistabioika.org/es/palabra-de-especialista/post?id=133&title=El aporte de la investigación cultural a la transición sostenible&label=Óscar Miguel Blanco Sierra&bgclass=especialista-bg&iconclass=especialista-icon-s-white&icon=" class="tooltipped bookmark" data-tooltip="Adicionar a Favoritos"><i class="material-icons">bookmark_border</i></span></div>
		</div>
	</div>



<div id="palabra-de-especialista_133-extra" class="hide"><div class="center-align"></div></div>

</div></div>

</div>