0byt3m1n1
Path:
/
home
/
mgatv524
/
public_html
/
sommatv
/
web
/
media
/
cache
/
0fea6a13c52b4d47
/
25368f24b045ca84
/
b8ac4316b44f99ee
/
f0cf6447439815bc
/
9d2b1ad5bbc16c44
/
d49116dc213c53f2
/
8a084cf70d891601
/
51bfe9722cb4c124
/
ae5fab1cdcea6d09
/
[
Home
]
File: 8a58d4014c1dda94.php
<?php /* Cachekey: cache/xibo/widget/ticker/a7eb4a156050112c04cdd163e27838a2/ */ /* Type: array */ /* Expiration: 2018-05-08T12:15:06-05:00 */ $loaded = true; $expiration = 1525799706; $data = array(); /* Child Type: array */ $data['return'] = unserialize(base64_decode('a:2:{s:8:"encoding";s:5:"utf-8";s:3:"xml";s:343847:"<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:webfeeds="http://webfeeds.org/rss/1.0" xmlns:media="http://search.yahoo.com/mrss/">
    <channel>
        <title>Notícias ao Minuto Brasil - Tech</title>
        <link>https://www.noticiasaominuto.com.br/rss/tech</link>
        <description><![CDATA[Brasil e o Mundo ao minuto]]></description>
        <atom:link href="https://www.noticiasaominuto.com.br/rss/tech" rel="self" type="application/rss+xml"/>
                            <webfeeds:accentColor>076da2</webfeeds:accentColor>
                            <webfeeds:cover image="https://cdn.noticiasaominuto.com.br/img/feedly_cover.jpg"/>
                            <webfeeds:icon>https://cdn.noticiasaominuto.com.br/img/feedly_profile.svg</webfeeds:icon>
                            <webfeeds:logo>https://cdn.noticiasaominuto.com.br/img/feedly_profile.svg</webfeeds:logo>
            <image>
                <url>https://cdn.noticiasaominuto.com.br/img/feedly_profile.svg</url>
                <title>Notícias ao Minuto Brasil - Tech</title>
                <link>https://www.noticiasaominuto.com.br/rss/tech</link>
            </image>
                                    <webfeeds:analytics id="UA-32939212-3" engine="GoogleAnalytics"/>
                <language>pt-BR</language>
        <lastBuildDate>Tue, 08 May 2018 13:23:36 -0300</lastBuildDate>
                            <item>
                    <title><![CDATA[Facebook testa botão de reação e adesivo com rosto de usuário]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/588245/facebook-testa-botao-de-reacao-e-adesivo-com-rosto-de-usuario?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/588245/facebook-testa-botao-de-reacao-e-adesivo-com-rosto-de-usuario?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Recurso é semelhante ao Bitmoji, do Snapchat]]></description>
                                            <content:encoded><![CDATA[<p>Depois de ter integrado o Stories a praticamente todos os serviços, parece que o Facebook ainda não acabou de se ‘inspirar’ no Snapchat. A rede social de Mark Zuckerberg se prepara para oferecer um recurso semelhante ao Bitmoji, do Snapchat.</p>

<p>Chamada de "Facebook Avatars", a função permitirá aos usuários criar versões ilustradas de si mesmos para usarem como ‘adesivos’.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/588239/industria-de-fraudes-comanda-boas-avaliacoes-na-amazon-diz-jornalista">+ Indústria de fraudes comanda boas avaliações na Amazon, diz jornalista</a></p>
<p>Conforme o TechCrunch, será possível personalizar a cor de pele, estilo de cabelo e outros pormenores faciais. O site revelou até algumas imagens dos "Avatars do Facebook".</p>
<p>Pelo que parece, a rede social permitirá usar estes stickers não só no Messenger mas ainda como reação a comentários. A justificativa do Facebook seria que, assim, ajuda "as pessoas a se expressarem melhor”. Os testes aos Avatars já estão acontecendo internamente. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto </dc:creator>
                    <pubDate>Tue, 08 May 2018 12:34:01 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af17c19db0e7.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Indústria de fraudes comanda boas avaliações na Amazon, diz jornalista]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/588239/industria-de-fraudes-comanda-boas-avaliacoes-na-amazon-diz-jornalista?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/588239/industria-de-fraudes-comanda-boas-avaliacoes-na-amazon-diz-jornalista?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Segundo investigação de Nicole Nguyen, a quem receba dinheiro para isso; e Amazon está impotente]]></description>
                                            <content:encoded><![CDATA[<p>A Amazon não apenas tem um grande fluxo de falsas avaliações de produtos como não tem como resolver o problema. A denúncia é da jornalista <a href="https://www.buzzfeed.com/nicolenguyen/amazon-fake-review-problem?utm_term=.imzObYa0ZK#.mo2a9q3Q8L" target="_blank">Nicole Nguyen</a>, que escreveu um artigo sobre o tema, intitulado "Inside Amazon's Fake Review Economy" (Por dentro do mercado de avaliações falsas da Amazon, em tradução livre).</p>

<p>O texto, publicado nesta segunda-feira (7), no BuzzFeed News, tem mexido com consumidores que se baseavam em boas avaliações para comprar. Segundo a denúncia, há quem receba dinheiro apenas para dar cinco estrelas (o máximo) para produtos ou lojas que nunca chegaram a usar ou nas quais nunca chegaram a comprar.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/588065/instagram-stories-pode-ter-trilha-sonora-em-breve">+ Instagram Stories pode ter trilha sonora em breve</a></p>
<p>A investigação da jornalista aponta que tais "trabalhadores" usam o Reddit, ou canais privados do Slack do Facebook para combinar o trabalho. A repórter, que divulgou um telefone encriptado para receber denúncias anônimas, lembrou ainda que a Amazon é a segunda empresa mais valiosa do mundo - com avaliação de US$ 760 bilhões, atrás apenas da Apple. A empresa de Jeff Bezos não se pronunciou, até o momento, sobre o assunto.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 08 May 2018 12:04:39 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af1be3b83ece.jpg?1525792429" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Nintendo anuncia que canal do Switch online terá nuvem e chat de voz]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/588135/nintendo-anuncia-que-canal-do-switch-online-tera-nuvem-e-chat-de-voz?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/588135/nintendo-anuncia-que-canal-do-switch-online-tera-nuvem-e-chat-de-voz?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Veja a lista de games já confirmados]]></description>
                                            <content:encoded><![CDATA[<p>A Nintendo revelou detalhes do Switch Online, canal exclusivo de jogos para a plataforma Switch, que entra no ar em setembro. Pelo custo de US$ 3,99 (cerca de R$ 14) ao mês ganha-se acesso online ao catálogo de 20 games da NES, com completa compatibilidade ao Switch.</p>

<p>Outros títulos que antes estavam disponíveis gratuitamente também entram no acervo, como "Splatoon 2", "Arms" e "Mario Kart 8 Deluxe" - antes disponíveis gratuitamente. De acordo com o anúncio desta terça-feira (8), o canal também suporta chamadas de voz, para smartphones; além de salvar dados do console na nuvem. </p>
<p><a href="https://www.noticiasaominuto.com.br/tech/588065/instagram-stories-pode-ter-trilha-sonora-em-breve">+Instagram Stories pode ter trilha sonora em breve</a></p>
<p>O plano de pagamento inclui opções de pagamento trimestral (US$ 7.99) e anual (US$ 19.99), além de um plano família, que engloba oito contas.</p>
<p><span class="news_h3" style="font-size: 1.2em; font-weight: bold; color: #006da6;">Confira alguns dos jogos já confirmados</span></p>
<p>Balloon Fight</p>
<p>Donkey Kong</p>
<p>Dr. Mario</p>
<p>Ice Climber</p>
<p>The Legend of Zelda</p>
<p>Mario Bros.</p>
<p>Soccer</p>
<p>Super Mario Bros.</p>
<p>Super Mario Bros. 3</p>
<p>Tennis</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 08 May 2018 08:49:56 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af18fa7e6197.jpg?1525780530" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Instagram Stories pode ter trilha sonora em breve]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/588065/instagram-stories-pode-ter-trilha-sonora-em-breve?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/588065/instagram-stories-pode-ter-trilha-sonora-em-breve?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Segundo o TechChrunch, código que promove mudança foi descoberto por leitor]]></description>
                                            <content:encoded><![CDATA[<p>O Instagram Stories poderá ter trilha sonora em breve. Pelo menos se um suposto código descoberto na versão do app para Android for realmente liberado para todos os usuários. O recurso permitiria incluir músicas a posts, de fotografias ou vídeos.</p>

<p>A programação foi revelada por Ishan Agarwal ao TechCrunch. Conforme os dois, a funcionalidade permitirá que as músicas sejam pesquisadas por gêneros, disposição e popularidade - incluindo o Instagram no acordo firmado entre o Facebook e a indústria musical, que inclui nomes como Warner e Universal.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587721/whatsapp-testa-conversa-rapida-entre-usuarios-fora-da-lista-de-contatos">+ WhatsApp testa conversa rápida entre usuários fora da lista de contatos</a></p>
<p>O Instagram também estaria testando uma forma de detectar automaticamente uma canção que o usuário esteja ouvindo e exibir informações como nome do artista e título da música em um <span class="news_italic">sticker</span>.</p>
<p>Além de prover trilha sonora, o novo recurso daria acesso ao compartilhamento de músicas direto de outros apps, como Spotify e SoundCloud. A ideia também seria, segundo o site, prover concorrência ao aplicativo de dublagem Musically, sensação entre usuários adolescentes. O Instagram não comentou a suposta novidade. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 08 May 2018 06:43:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af1709f68226.jpg?1525772531" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[WhatsApp testa conversa rápida entre usuários fora da lista de contatos]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587721/whatsapp-testa-conversa-rapida-entre-usuarios-fora-da-lista-de-contatos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587721/whatsapp-testa-conversa-rapida-entre-usuarios-fora-da-lista-de-contatos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Recurso está na versão beta do app]]></description>
                                            <content:encoded><![CDATA[<p>A mais nova versão beta do WhatsApp para Android foi disponibilizada no Google Play. Uma das atualizações testa o domínio wa.me, registrado pelo mensageiro. A ideia deste recurso do upgrade 2.18.138 é permitir acesso rápido a uma conversa entre usuários que não estão registrados nos contatos mútuos.</p>

<p>O <span class="news_italic">wa.me</span> direciona ao <span class="news_italic">api.whatsapp.com</span>, um endereço de internet que permite acessar uma conversa rapidamente, na função chamada "click to chat" (em português livre, clique para conversar).</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587695/vingadores-guerra-infinita-entre-os-mais-pirateados-da-semana">+ 'Vingadores: Guerra Infinita' entre os mais pirateados da semana</a></p>
<p>O link compartilhável facilita a conversa e promete ser útil para quem não quiser divulgar o próprio número ou não precisa cadastrar o contato na agenda do celular. A janela de chat permite compartilhar imagem, áudio e vídeo, além de textos. Uma nova lista de emojis também está sendo testado.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 08 May 2018 06:14:44 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af079ad1b7dc.jpg?1525709335" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Clientes reclamam após aplicativo do Itaú sair do ar nesta segunda]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/588005/clientes-reclamam-apos-aplicativo-do-itau-sair-do-ar-nesta-segunda?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/588005/clientes-reclamam-apos-aplicativo-do-itau-sair-do-ar-nesta-segunda?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Banco recomenda que transações e consultas pelo telefone, caixas eletrônicos ou agências]]></description>
                                            <content:encoded><![CDATA[<p>O aplicativo do banco Itáu apresentou problemas técnicos na tarde desta segunda-feira (7). A instituição bancária utilizou sua página no Twitter para responder queixas de alguns clientes.</p>

<p>Caso tenha problemas em acessar sua plataforma, o Itaú recomenda que clientes façam transações e consultas pelo telefone, caixas eletrônicos ou agências. Até o momento, a causa do problema não foi informada pelo banco.</p>
<p>Em resposta a uma cliente na rede social, o banco informou que a conexão foi restabelecida por volta das 21:40h. </p>
<blockquote class="twitter-tweet" data-lang="pt">
<p dir="ltr" lang="pt">Tente um novo acesso, por favor. Recebemos informações sobre o restabelecimento do acesso.</p>
— Itaú (@itau) <a href="https://twitter.com/itau/status/993653171116527618?ref_src=twsrc%5Etfw">8 de maio de 2018</a></blockquote>
<p>
<script charset="utf-8" src="https://platform.twitter.com/widgets.js" async=""></script>
</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587793/saiba-se-seu-convite-para-seguir-no-instagram-foi-recusado" target="_blank">Saiba se seu convite para seguir no Instagram foi recusado</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 22:30:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a7aefc40558c.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Uber já sabe o que causou o acidente fatal com carro autônomo nos EUA]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/588003/uber-ja-sabe-o-que-causou-o-acidente-fatal-com-carro-autonomo-nos-eua?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/588003/uber-ja-sabe-o-que-causou-o-acidente-fatal-com-carro-autonomo-nos-eua?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Vítima foi atropleada no mês de março em Tempe, no Arizona]]></description>
                                            <content:encoded><![CDATA[<p>O Uber se envolveu, em março, em um acidente fatal com um veículo autônomo nos Estados Unidos. Elaine Herzberg, de 49 anos, morreu atropelada em Tempe, no Arizona. As causas do acidente estavam sendo investigadas pelo Uber e pela National Transportation Safety Board (NTSB) - até agora.</p>

<p>De acordo o TecMundo, o Uber  já sabe o que causou o acidente. Embora a empresa ainda não tenha se manifestado oficialmente sobre o caso, fontes próximas contam que os sensores que deveriam detectar "objetos", como pedestres ou bicicletas, não estavam calibrados da maneira adequada. Tudo indica que o programa estava mais "suave" no momento do acidente.</p>
<p>Dias após o acidente, autoridades norte-americanas divulgaram<span class="news_bold"> imagens fortes</span> do momento do atropelamento. <a href="https://www.noticiasaominuto.com.br/tech/566856/imagens-fortes-mostram-acidente-fatal-com-carro-autonomo-da-uber" target="_blank">Veja aqui</a>. </p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587964/cientistas-apontam-quando-e-como-o-sol-ira-morrer" target="_blank">Cientistas apontam quando e como o sol irá 'morrer'</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 22:16:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ab2ffd01e18b.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Thanos, vilão de 'Vingadores: Guerra Infinita', aparecerá no Fortnite]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587882/thanos-vilao-de-vingadores-guerra-infinita-aparecera-no-fortnite?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587882/thanos-vilao-de-vingadores-guerra-infinita-aparecera-no-fortnite?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Atualização estará disponível gratuitamente]]></description>
                                            <content:encoded><![CDATA[<p>Agora que a batalha contra os Vingadores terminou em "Guerra Infinita", Thanos, o supervilão da Marvel, está disponível para fazer uma "participação especial" no jogo Fortnite. A novidade foi divulgada pelo portal Entertainment Weekly. </p>

<p>O crossover dos universos passa a acontecer a partir desta terça (8) e a atualização estará disponível para todas as plataformas de Fortnite gratuitamente, por tempo limitado mas ainda indeterminado pelos desenvolvedores.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/587853/estudo-revela-exoplaneta-sem-nuvens" target="_blank">Estudo revela exoplaneta sem nuvens</a></p>
<p>A aparição do vilão acontece em um novo modo de jogo, o Infinity Gauntlet. Similar ao modo de jogo normal, Battle Royale, 100 jogadores caem em um mapa e se enfrentam normalmente, com a diferença de que, em algum lugar da arena, está escondida a Manopla do Infinito, a poderosa luva de Thanos.</p>
<p>O jogador que encontrar a Manopla do Infinito se transformará no próprio personagem e terá acesso a todos os seus poderes. </p>
<p>A ideia da mistura partiu dos próprios diretores de Vingadores, Joe e Anthony Russo, que fizeram a proposta à Donald Mustard, diretor criativo da Epic Games, empresa responsável pelo Fortnite. </p>
<p>"Nos últimos meses, enquanto estávamos editando 'Guerra Infinita', fazíamos pequenas pausas para dar uma olhada em alguns jogos", disse Joe em entrevista à publicação. "E então começamos a pensar como seria legal se tivesse algum tipo de mistura entre os Vingadores e Fortnite."</p>
<p>"Guerra Infinita nos surpreendeu muito, e os Russos [irmãos diretores da Marvel], Kevin Feige [presidente dos estúdios Marvel] e todo o time trabalharam de forma incrível conosco", disse Mustard. </p>
<p>"Esse tipo de oportunidade, em que você tem respeito mútuo por alguém com quem trabalha e pensam do mesmo jeito sobre fazer algo legal para os fãs é realmente raro e empolgante. Esperamos que todos gostem!", afirmou o diretor da Epic Games. Com informações da Folhapress. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Folhapress</dc:creator>
                    <pubDate>Mon, 07 May 2018 21:47:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af0f374d9688.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Órbita da Terra muda a cada 405 mil anos, alterando clima global]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587967/orbita-da-terra-muda-a-cada-405-mil-anos-alterando-clima-global?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587967/orbita-da-terra-muda-a-cada-405-mil-anos-alterando-clima-global?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Estudo se baseou em escavações feitas em rochas extremamente antigas do Arizona]]></description>
                                            <content:encoded><![CDATA[<p>Um novo estudo demonstra que a influência gravitacional de Júpiter e de Vênus provoca, a cada 405 mil anos, uma alteração na órbita da Terra que tem impactos no clima global. De acordo com os autores da pesquisa, publicada nesta segunda-feira, 7, na revista científica PNAS, esse ciclo já havia sido previsto por cálculos de mecânica celeste, mas até agora ninguém havia apresentado evidências físicas de sua existência.</p>

<p>Segundo os autores, o estudo, que se baseou em escavações feitas em rochas extremamente antigas do Arizona (Estados Unidos), comprovou que o fenômeno tem ocorrido regularmente há pelo menos 215 milhões de anos - antes do aparecimento dos dinossauros -, deixando a órbita mais "alongada".</p>
<p>+<a href="https://www.noticiasaominuto.com.br/tech/587964/cientistas-apontam-quando-e-como-o-sol-ira-morrer" target="_blank"> Cientistas apontam quando e como o sol irá 'morrer'</a></p>
<p>"É um resultado espantoso, porque a existência desse longo ciclo, que já havia sido prevista a partir da análise dos movimentos dos planetas nos últimos 50 milhões de anos, foi comprovada e já ocorre há pelo menos 215 milhões de anos. Agora os cientistas poderão ligar esse ciclo de 405 mil anos, de uma maneira muito precisa, às alterações no clima, no ambiente e na evolução dos dinossauros e dos mamíferos, por exemplo", disse o autor principal do estudo, Dennis Kent, da Universidade Rutgers, nos Estados Unidos.</p>
<p>Por várias décadas, os cientistas postulavam que a órbita da Terra em torno do Sol sofre uma modificação a cada 405 mil anos, passando de uma forma quase circular para uma forma 5% mais alongada, ou elíptica.</p>
<p>O ciclo, segundo eles, é resultado de uma complexa interação com as influências gravitacionais de Vênus, Júpiter e outros objetos do Sistema Solar, que em sua viagem em torno do Sol às vezes estão mais próximos e às vezes mais distantes uns dos outros.</p>
<p>Segundo os astrofísicos, porém, o cálculo matemático desse ciclo só era confiável nos últimos 50 milhões de anos. Para além desse limite, o problema se torna complexo demais, porque há muitas variáveis em jogo.</p>
<p>"Há outros ciclos orbitais mais curtos, mas quando olhamos para o passado, é muito difícil saber quais deles têm relações entre si, porque eles mudam muito com o tempo. A beleza desse ciclo maior é que ele não muda. Todos os outros ciclos é que mudam em relação a ele", disse Kent.</p>
<p><strong>Escrito nas rochas</strong></p>
<p>A evidência que demonstra a existência do ciclo há pelo menos 215 milhões de anos são amostras de rocha retiradas de até 500 metros de profundidade de uma colina no Parque Nacional da Floresta Petrificada, no Arizona, em 2013.</p>
<p>As rochas do Arizona que foram estudadas se formaram durante o fim do período Triássico, entre 209 e 215 milhões de anos atrás, quando a área era coberta por rios que carreavam sedimentos. Nessa época, os primeiros dinossauros estavam começando a evoluir.</p>
<p>Os cientistas determinaram a idade das rochas do Arizona analisando as camadas de cinzas vulcânicas em seu interior que contêm radioisótopos cuja emissão radioativa decai em uma taxa constante. A partir dos sedimentos, eles também detectaram repetidas inversões na polaridade do campo magnético do planeta.</p>
<p>Antes de escavar o solo no Arizona para obter os "testemunhos de rocha" - como são chamados os "cilindros" de rocha de centenas de metros de comprimento - os cientistas já haviam obtidos testemunhos em Nova Jersey, que mostravam uma alternância entre períodos secos e úmidos ao longo de milhões de anos.</p>
<p>Eles acreditavam que essas mudanças do clima registradas nas rochas de Nova Jersey eram controladas pelo ciclo de 405 mil anos, mas naquelas rochas não havia camadas de cinzas vulcânicas que permitissem determinar as datas com precisão.</p>
<p>Combinando os dois conjuntos de dados - obtidos em Nova Jersey e no Arizona -, os cientistas demonstraram que os dois locais se desenvolveram ao mesmo tempo e que o intervalo de 405 mil anos de fato está ligado às variações do clima.</p>
<p><strong>Profusão de ciclos</strong></p>
<p>Outro dos autores da pesquisa, o paleontólogo Paul Olsen, afirma que o ciclo não muda o clima diretamente, mas intensifica ou enfraquece os efeitos de outros ciclos de duração mais curta, que por sua vez afetam o clima diretamente. Em conjunto, esses ciclos mudam as proporções de energia solar que atingem a Terra em diferentes momentos do ano.</p>
<p>Ele explica que há um ciclo menor a cada 100 mil anos, ligado à excentricidade da órbita da Terra, um de 41 mil anos, ligado à inclinação do eixo da Terra em relação à órbita em torno do Sol e um ciclo de 21 mil anos ligado a uma oscilação no eixo da Terra. Na década de 1970, cientistas revelaram que esses ciclos menores levaram à alternância entre períodos de aquecimento e resfriamento do planeta, produzindo as glaciações.</p>
<p>Mas ainda há muita discussão sobre as inconsistências nos dados dos últimos milhões de anos e sobre as relações desses ciclos com o aumento e redução dos níveis de dióxido de carbono na atmosfera - outro fator que controla o clima global. O que torna os resultados desses fenômenos ainda mais difíceis de entender é a interação constante entre eles. Eventualmente, um ciclo está fora de fase em relação aos outros e uns tendem a neutralizar os outros. Outras vezes, eles podem se combinar provocando mudanças drásticas e súbitas.</p>
<p>Segundo os autores do novo estudo, a cada 405 mil anos, quando a excentricidade - ou "alongamento" - da órbita está em seu máximo, diferenças sazonais provocadas pelos ciclos mais curtos se tornam mais intensas, deixando os verões mais quentes, os invernos mais frios, os locais secos mais secos e os locais úmidos mais úmidos. Tudo se inverte 202,5 mil anos depois, quando a órbita da Terra se torna mais circular.</p>
<p>Os cientistas explicam que Júpiter e Vênus exercem forte influência na órbita da Terra por causa do tamanho e da proximidade, respectivamente. Vênus é o planeta mais próximo da Terra, afastando-se dela no máximo 260 milhões de quilômetros. Júpiter está muito mais longe, mas é maior planeta do Sistema Solar, 2,5 vezes maior que a soma de todos os demais.</p>
<p><strong>Efeito estufa é decisivo</strong></p>
<p>Segundo Olsen, o sistema é tão intrincado que ainda há muita pesquisa a ser feita para que se compreenda completamente as relações entre a órbita e o clima da Terra. "É uma coisa realmente complicada. Nós utilizamos basicamente o mesmo tipo de conhecimento matemático que é utilizado para enviar espaçonaves a Marte - e que funciona muito bem na prática. Mas quando começamos a estudar os movimentos interplanetários em um passado mais remoto e a ligá-los a mudanças no clima, temos que admitir que não entendemos todo o funcionamento."</p>
<p>Neste momento, segundo os cientistas, a órbita da Terra está no momento mais "circular" dos últimos 405 mil anos. "Para nós isso provavelmente não tem nenhum significado muito perceptível. Esse ciclo está bem longe do topo da lista de coisas que podem afetar o clima em escalas de tempo que nos afetem. Neste momento, todo o dióxido de carbono que nós lançamos na atmosfera é um problema muito maior, com efeitos muito mais importantes nas nossas vidas. O ciclo planetário é bem mais sutil", disse Kent. Com informações do Estadão Conteúdo. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Estadao Conteudo</dc:creator>
                    <pubDate>Mon, 07 May 2018 21:17:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a5f0ca784140.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Microfone do iPhone 7 está dando problema? Saiba o que fazer]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587810/microfone-do-iphone-7-esta-dando-problema-saiba-o-que-fazer?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587810/microfone-do-iphone-7-esta-dando-problema-saiba-o-que-fazer?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Usuários do modelo já notaram o bug, mas a Apple ainda não se pronunciou oficialmente sobre o caso]]></description>
                                            <content:encoded><![CDATA[<p>Após a atualização para iOS 11.3, usuários de iPhone 7 e iPhone 7 Plus tem notado um bug no microfone. O portal MacRumors adquiriu um documento interno da Apple, em que a empresa se mostra ciente do caso e autoriza assistências a realizarem testes em aparelhos que apresentarem estes problemas.</p>

<p>De acordo com o 'Techtudo', a falha pode estar no software do iPhone, que impede a realização de ligações pelo telefone ou FaceTime. É aconselhável que usuários desconectem acessórios Bluetooth para tentar resolver o problema. Caso mensagens como "O dispositivo não pôde se conectar ao dock" persistirem, <span class="news_bold">clientes devem levar o iPhone a um suporte técnico da fabricante.</span></p>
<p>Até o momento, a Apple não se pronunciou oficialmente sobre o bug.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587793/saiba-se-seu-convite-para-seguir-no-instagram-foi-recusado" target="_blank">Saiba se seu convite para seguir no Instagram foi recusado</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 21:00:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aa92116e45bb.jpg?1525720246" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Cientistas apontam quando e como o sol irá 'morrer']]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587964/cientistas-apontam-quando-e-como-o-sol-ira-morrer?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587964/cientistas-apontam-quando-e-como-o-sol-ira-morrer?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Não precisa ficar preocupado: ainda faltam 10 bilhões de anos para a explosão]]></description>
                                            <content:encoded><![CDATA[<p>Que o Sol irá acabar em uma data longínqua, nós já sabíamos, mas como será o evento? Um estudo recente publicado na revista científica Nature descreve as etapas finais do astro.</p>

<p>De acordo com o CanalTech, os cientistas achavam anteriormente que o sol ficaria parecido com uma nebulosa após a explosão. A nova pesquisa sugere que a vida do Sol deve acabar daqui a cerca de 10 bilhões de anos. Mas antes disso, daqui a 5 bilhões de anos, o astro se tornará uma gigante vermelha - tal como acontece com a maioria das estrelas similares do universo.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/587853/estudo-revela-exoplaneta-sem-nuvens" target="_blank">Estudo revela exoplaneta sem nuvens</a></p>
<p>A tese indica que à medida em que o núcleo solar for diminuindo, as camadas externas do Sol irão se expandir para além da órbita de Marte, "devorando" o que estiver pela frente. Depois, o astro irá se transformar em uma anã-branca para, no fim, restar apenas a tal nebulosa já prevista.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 20:33:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af0e13e8e810.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Firefox terá anúncios em forma de link patrocinado]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587914/firefox-tera-anuncios-em-forma-de-link-patrocinado?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587914/firefox-tera-anuncios-em-forma-de-link-patrocinado?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[O navegador era um dos mais apreciados pelos defensores de privacidade]]></description>
                                            <content:encoded><![CDATA[<p>O Mozilla anunciou que o seu navegador de internet, Firefox, terá conteúdo patrocinado em links sugeridos - isto é, os tão odiados anúncios publicitários.</p>

<p>Conta o The Verge que os anúncios vão surgir nos links para leitura sugeridos pelo serviço Pocket. Os responsáveis garantem que serão apenas patrocinados os links que mereçam a atenção dos usuários.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/587810/microfone-do-iphone-7-esta-dando-problema-saiba-o-que-fazer" target="_blank">Microfone do iPhone 7 está dando problema? Saiba o que fazer</a></p>
<p>O Firefox manteve-se ao longo dos últimos anos como uma das alternativas mais recorridas em relação ao popular Google Chrome. O navegador é adorado especialmente por defensores de privacidade.</p>
<p>Mesmo que tenha se mantido livre de anúncios até agora, parece que o Mozilla foi obrigado a integrar esta forma de gerar receita com o seu navegador de internet.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 19:45:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af0d6a3e252e.jpg?1525733117" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Estudo revela exoplaneta sem nuvens]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587853/estudo-revela-exoplaneta-sem-nuvens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587853/estudo-revela-exoplaneta-sem-nuvens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Equipe internacional de astrônomos explica o fenômeno]]></description>
                                            <content:encoded><![CDATA[<p>Uma equipe internacional de astrônomos liderada por Nikolay Nikolov, da Universidade de Exeter, no Reino Unido, acredita que não há nuvens no exoplaneta WASP-96b. O fenômeno ocorre por conta do sódio característico de sua atmosfera.</p>

<p>Uma pesquisa divulgada na revista 'Nature' desta segunda-feira (7) revela que o sódio presente neste planeta impede a absorção do vapor de água, o que é necessário para a formação das nuvens.</p>
<p>"Ao observar todas as atmosferas dos exoplanetas, obteremos uma melhor compreensão sobre a formação das nuvens", diz o coautor do estudo, Jonathan Fortney.</p>
<p>O planeta, localizado fora do Sistema Solar, foi observado por meio do "Very Large Telescope", que fica no Chile. De acordo com o G1, o aparelho é considerado o telescópio mais avançado do mundo atualmente.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587793/saiba-se-seu-convite-para-seguir-no-instagram-foi-recusado" target="_blank">Saiba se seu convite para seguir no Instagram foi recusado</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 18:31:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af0b49a6494c.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Saiba se seu convite para seguir no Instagram foi recusado]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587793/saiba-se-seu-convite-para-seguir-no-instagram-foi-recusado?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587793/saiba-se-seu-convite-para-seguir-no-instagram-foi-recusado?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Função só está disponível na versão desktop da rede social]]></description>
                                            <content:encoded><![CDATA[<p>Você pediu para seguir uma conta privada do Instagram, mas não recebeu o alerta de que foi aceito? De duas, uma: ou o usuário não viu seu pedido ou ele recusou a nova amizade.</p>

<p>Se está curioso para descobrir qual foi o caso, saiba que o <span class="news_bold">Instagram Web</span> permite que você verifique se a pessoa recusou seu pedido para seguir. Para isso, entre na versão desktop e clique no ícone de avatar no canto superior direito da tela. Depois, selecione as Configurações da rede social e selecione a opção Privacidade e Segurança.</p>
<p>O próximo passo é entrar na seção <span class="news_bold">Dados da conta</span> e clicar em <span class="news_bold">Ver dados da conta</span>. Em <span class="news_bold">Conexões</span>, escolha a opção Solicitações para seguir atuais e, por fim, clique em<span class="news_bold"> Ver tudo</span>. Pronto! Agora os usuários que não aceitaram seu pedido para seguir vão aparecer na tela.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587721/whatsapp-testa-conversa-rapida-entre-usuarios-fora-da-lista-de-contatos" target="_blank">WhatsApp testa conversa rápida entre usuários fora da lista de contatos</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 15:18:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af097ba05cec.jpg?1525717214" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA['Vingadores: Guerra Infinita' entre os mais pirateados da semana]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587695/vingadores-guerra-infinita-entre-os-mais-pirateados-da-semana?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587695/vingadores-guerra-infinita-entre-os-mais-pirateados-da-semana?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Lista foi divulgada pelo TorrentFreak]]></description>
                                            <content:encoded><![CDATA[<p>"Pantera Negra" foi o filme mais pirateado da semana, no ranking divulgado pela TorrentFreak. O herói de Wakanda abre a lista, seguido de perto por "Vingadores: Guerra Infinita", que continua batendo recordes de bilheteria no cinema. Na terceira posição, "A Noite do Jogo", suspense com Rachel McAdams e Jason Bateman. "Thor: Ragnarok" também está na lista.</p>

<p><span class="news_h3" style="font-size: 1.2em; font-weight: bold; color: #006da6;">Confira os 10 filmes mais pirateados da semana</span></p>
<p>1. Pantera Negra</p>
<p>2. Vingadores: Guerra Infinita</p>
<p>3. A Noite do Jogo</p>
<p>4. Anon</p>
<p>5. 12 Heróis</p>
<p>6. Cinquenta Tons de Liberdade</p>
<p>7. Círculo de Fogo: A Revolta</p>
<p>8. Covil de Ladrões</p>
<p>9. Sansão</p>
<p>10. Thor: Ragnarok</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 12:28:02 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a1ef09c40a35.jpg?1525707022" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA['Red Dead Redemption 2' é candidato a jogo do ano; veja novas imagens]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587600/red-dead-redemption-2-e-candidato-a-jogo-do-ano-veja-novas-imagens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587600/red-dead-redemption-2-e-candidato-a-jogo-do-ano-veja-novas-imagens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Lançamento está marcado para 26 de outubro na PlayStation 4 e Xbox One]]></description>
                                            <content:encoded><![CDATA[<p>Mais conhecida pela série ‘GTA’, a Rockstar Games lançará a sequência de "Red Dead Redemption", sucesso de 2010.  Ambientado no Velho Oeste, "Red Dead Redemption 2" promete ser um dos jogos do ano. </p>

<p>O jogo em um mundo aberto à exploração é repleto de atividades secundárias que complementarão uma narrativa certamente memorável.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587554/youtube-remove-videos-que-promovem-fraude-em-trabalhos-escolares">+ YouTube remove vídeos que promovem fraude em trabalhos escolares</a></p>
<p>O lançamento está marcado para 26 de outubro na PlayStation 4 e Xbox One.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 09:18:58 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af0317dc75ff.jpg?1525696055" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[YouTube remove vídeos que promoviam fraude em trabalhos escolares]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587554/youtube-remove-videos-que-promoviam-fraude-em-trabalhos-escolares?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587554/youtube-remove-videos-que-promoviam-fraude-em-trabalhos-escolares?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A ação procede uma denúncia da rede britânica BBC, que encontrou mais de 250 canais sobre uma compan]]></description>
                                            <content:encoded><![CDATA[<p>Se depender do YouTube, os vídeos com propagandas que incentivam fraudes em trabalhos escolares estão com os dias contados. A plataforma está realizando uma espécie de operação "pente fino" em canais que promovem serviços de escrita de ensaios ou projetos. Milhares de vídeos já foram removidos do catálogo, segundo anunciou o YouTube nesta segunda-feira (7).</p>

<p>A ação procede uma denúncia da rede britânica BBC, que encontrou mais de 250 canais sobre uma companhia ucraniana chamada EduBirdie, que vende ensaios a "estudantes desesperados".</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587490/youtube-music-vai-mudar-de-visual-e-as-primeiras-imagens-ja-vazaram">+ YouTube Music vai mudar de visual e as primeiras imagens já vazaram</a></p>
<p>A empresa, que financia diversos vídeos, promete pesquisa e texto, de acordo com os padrões educacionais internacionais, que podem ainda serem personalizados para a escola ou universidade.</p>
<p>Nas contas da BBC, os vídeos somam milhões de visualizações. O YouTube alcançou, nesta sexta-feira (4), a marca de 1.8 bilhões de usuários ativos por mês, número menor apenas que o Google.com.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 07:51:11 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5af03051a37ed.jpg?1525690564" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Não gostou do novo Gmail? Volte ao visual antigo em apenas 2 passos]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587371/nao-gostou-do-novo-gmail-volte-ao-visual-antigo-em-apenas-2-passos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587371/nao-gostou-do-novo-gmail-volte-ao-visual-antigo-em-apenas-2-passos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Saiba como voltar ao visual antigo do correio eletrônico]]></description>
                                            <content:encoded><![CDATA[<p>O Gmail para web ganhou uma verdadeira repaginada no visual há duas semanas. Mas se você não gostou do novo look do correio virtual, o TecMundo garante que é possível voltar ao layout anterior de forma bem simples.</p>

<p>Para deixar o desing moderninho, o usuário só precisa ir nas Configurações do Gmail e selecionar a opção Voltar para o Gmail Clássico. Simples, não?</p>
<p>Leia também:<a href="https://www.noticiasaominuto.com.br/tech/587360/5-celulares-que-ja-foram-top-de-linha-e-agora-custam-menos-de-r-2-mil" target="_blank"> 5 celulares que já foram top de linha e agora custam menos de R$ 2 mil</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 05:41:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae4c818b2507.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Novos notebooks Style da Samsung chegam ao Brasil; veja os valores]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587502/novos-notebooks-style-da-samsung-chegam-ao-brasil-veja-os-valores?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587502/novos-notebooks-style-da-samsung-chegam-ao-brasil-veja-os-valores?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Confira as especificidades dos modelos]]></description>
                                            <content:encoded><![CDATA[<p>A Samsung realizou um evento em São Paulo neste semana para apresentar o portfólio de laptops para 2018 no país. Entre as novidades, estão os notebooks Styles: o S51 Pro, que oferece portabilidade sem abandonar o alto desempenho; S51 Pen, que vem equipado com a caneta S Pen. Confira as especificidades dos modelos:</p>

<p>+ <a href="https://www.noticiasaominuto.com.br/tech/587470/conheca-o-app-chines-mais-baixado-que-whatsapp-facebook-e-youtube" target="_blank">Conheça o app chinês mais baixado que WhatsApp, Facebook e YouTube</a></p>
<p><span class="news_bold">Style S51 Pro</span></p>
<p>O modelo é de 15 polegadas full HD e 450 nits de brilho, o acabamento é todo em Metal12TM e as bordas da tela são finas, permitindo melhor aproveitamento do espaço frontal. Outro detalhe é o peso de 1,29 kg.</p>
<p>Segundo a empresa, um recurso importante do S51 Pro é a recarga rápida. Em apenas 20 minutos o usuário pode conseguir mais 23% de bateria. Há ainda o leitor de impressões digitais, que além de facilitar o acesso, oferece maior proteção aos dados do usuário.O notebook é equipado com a 8ª geração de processadores Intel e 256GB de SSD.</p>
<p>O modelo está sendo vendido no Brasil na cor prata, com preço sugerido de R$ 8.999.</p>
<p><span class="news_bold">Style S51 Pen</span></p>
<p>Um dos conversíveis mais leves da categoria, o S51 Pen chama a atenção por oferecer a famosa caneta S Pen, redefinindo o jeito de usar o notebook. Com este acessório, o usuário poderá realizar anotações, fazer desenhos ou até ativar atalhos na tela com o Comando Suspenso. A companhia reforça que a caneta não possui bateria, por isso, é só puxar e sair usando.</p>
<p>O S51 Pen conta com uma tela sensível ao toque de 13,3 polegadas, full HD, 450 nits e rotação de 360 graus, o que permite deixar o notebook em 4 posições (tradicional, tenda, apresentação e tablet). O aparelho pesa 995 gramas. Com o Windows Hello, é possível fazer o login com reconhecimento facial, além do leitor de impressões digitais. O laptop traz a 8ª geração de processadores Intel Core i7.</p>
<p>Para quem deseja um formato mais tradicional de notebook, o Style S51, oferece os mesmos recursos e configurações do S51 Pen, com exceção da S-Pen e da tela sensível, oferecendo muita praticidade aos consumidores, graças a tela de 13,3 polegadas.</p>
<p>O Style S51 Pen e o Style S51 chegam ao Brasil na cor prata, com preços sugeridos de R$ 8.499 e R$ 7.499, respectivamente.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 07 May 2018 04:59:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aefa9ccdbf24.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[YouTube Music vai mudar de visual e as primeiras imagens já vazaram]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587490/youtube-music-vai-mudar-de-visual-e-as-primeiras-imagens-ja-vazaram?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587490/youtube-music-vai-mudar-de-visual-e-as-primeiras-imagens-ja-vazaram?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Diferenças foram notadas por um usuário do reddit]]></description>
                                            <content:encoded><![CDATA[<p>O aplicativo YouTube Play - a vertente da plataforma voltada para streaming musical - está mudando o visual aos poucos. Um usuário do Reddit notou as diferenças no layout e fez um fórum para propagar estas mudanças.</p>

<p>De acordo com o 'TecMundo', o app está com um layout mais minimalista no modo reprodução. As mudanças também facilitaram a organização das músicas "em fila". Além disso, o modo aleatório passou a mostrar a ordem as faixas. <a href="https://i.imgur.com/QXMCRM8.gif" target="_blank">Veja aqui um GIF </a>que mostra estas alterações. </p>
<p><img class="tinymceimage img-responsive" src="http://static.noticiasaominuto.com.br/stockimages/gallery/640/naom_5aefa0228637c.jpg" border="0" alt="Notícias ao Minuto" /></p>
<p>O YouTube confirmou as mudanças ao site especializado The Verge. Agora, resta saber se haverá também alterações no próprio serviço streaming. </p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587470/conheca-o-app-chines-mais-baixado-que-whatsapp-facebook-e-youtube" target="_blank">Conheça o app chinês mais baixado que WhatsApp, Facebook e YouTube</a></p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 21:45:01 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aefa17aab942.jpg?1525653946" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Conheça o app chinês mais baixado que WhatsApp, Facebook e YouTube]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587470/conheca-o-app-chines-mais-baixado-que-whatsapp-facebook-e-youtube?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587470/conheca-o-app-chines-mais-baixado-que-whatsapp-facebook-e-youtube?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Rede social Tik Tok é uma febre entre jovens chineses]]></description>
                                            <content:encoded><![CDATA[<p>O relatório trimestral da Sensor Tower, consultora que analisa o mercado de apps, revelou um dado interessante em relação às plataformas favoritas na App Store. Segundo o levantamento, o líder no raking de downloads é um aplicativo chinês chamado Tik Tok.</p>

<p>De acordo com o UOL, o Tik Tok teve 45,8 milhões de downloads. A marca é impressionante pois supera números de aplicativos bem populares, como WhatsApp, YouTube, Instagram e Facebook.</p>
<p>O aplicativo é uma rede social de vídeos musicais curtos. A plataforma é uma febre entre jovens chineses. Segundo a reportagem, ele permite que usuários produzam clipes de dublagem para compartilhar com amigos. Para isso, o app utiliza reconhecimento facial.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587371/nao-gostou-do-novo-gmail-volte-ao-visual-antigo-em-apenas-2-passos" target="_blank">Não gostou do novo Gmail? Volte ao visual antigo em apenas 2 passos</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 21:00:17 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aef97c046d7f.jpg?1525651440" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Apesar do escândalo, maioria dos usuários continua fiel ao Facebook]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587468/apesar-do-escandalo-maioria-dos-usuarios-continua-fiel-ao-facebook?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587468/apesar-do-escandalo-maioria-dos-usuarios-continua-fiel-ao-facebook?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Pesquisa aponta que metade dos participantes não mudou a rotina na rede social]]></description>
                                            <content:encoded><![CDATA[<p>Uma pesquisa feita pela Reuters/Ipsos aponta que a maioria dos usuários do Facebook permaneceu fiel à rede social apesar do escândalo do uso indevido de milhões de dados pessoais pela consultoria política Cambridge Analytica.</p>

<p>De acordo com o jornal 'O Globo', metade dos usuários dos Estados Unidos não mudou a rotina na rede social, e um quarto dos entrevistados afirmou que estavam usando o Facebook ainda mais após o escândalo.</p>
<p>A pesquisa também mostrou que apenas 3% dos participantes dizem ter encerrado a conta. E outros 4% alegam que mantiveram suas contas, mas deixaram de acessar a rede social.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587371/nao-gostou-do-novo-gmail-volte-ao-visual-antigo-em-apenas-2-passos" target="_blank">Não gostou do novo Gmail? Volte ao visual antigo em apenas 2 passos</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 20:34:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae1ff70363c8.jpg?1525649667" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Pesquisa da UFMG vai comparar efeitos de medicamentos para HIV]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587359/pesquisa-da-ufmg-vai-comparar-efeitos-de-medicamentos-para-hiv?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587359/pesquisa-da-ufmg-vai-comparar-efeitos-de-medicamentos-para-hiv?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Estudo está recrutando participantes]]></description>
                                            <content:encoded><![CDATA[<p>Pesquisadores da Faculdade de Medicina da Universidade Federal de Minas Gerais (UFMG) estão recrutando participantes para um estudo que pretende comparar dois medicamentos considerados equivalentes para a Profilaxia Pré-Exposição ao HIV (PrEP), um que atualmente precisa ser importado e outro já produzido no Brasil. Poderão se voluntariar quem se enquadre nos grupos considerados chave: homens que fazem sexo com outros homens e pessoas trans com pelo menos 18 anos.</p>

<p>Os interessados devem buscar o Centro de Referência em Doenças Infecciosas e Parasitárias Orestes Diniz, no centro de Belo Horizonte. Haverá uma triagem e serão selecionadas ao final 200 pessoas. Metade delas fará uso de um dos medicamentos e a outra metade do outro. Os participantes não saberão qual a versão estarão tomando. O acompanhamento se dará ao longo de 12 meses.</p>
<p>A PrEP é uma pílula antirretroviral que forma uma barreira química e impede a infecção por HIV. Seu uso deve ocorrer diariamente e depende de prescrição e acompanhamento médico. Se tomado corretamente conforme as orientações, sua proteção pode alcançar percentual próximo a 100%. Especialistas recomendam  que o método deve ser combinado com outras medidas, incluindo o uso de preservativos, que protege contra as demais doenças sexualmente transmissíveis (DSTs).</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/587371/nao-gostou-do-novo-gmail-volte-ao-visual-antigo-em-apenas-2-passos" target="_blank">Não gostou do novo Gmail? Volte ao visual antigo em apenas 2 passos</a></p>
<p>O Brasil foi pioneiro na América Latina ao adotá-lo como política de saúde. O Sistema Único de Saúde (SUS) distribui desde o fim do ano passado o medicamento para grupos específicos considerados chave no combate à Aids. Entre eles, estão homens que fazem sexo com homens, <em>gays</em>, pessoas trans, profissionais do sexo e casais em que um membro é soropositivo e o outro não é.</p>
<p>A marca mais difundida no mercado internacional é o medicamento Truvada, da empresa norte-americana Gilead. Trata-se de uma associação dos fármacos Emtricitabina e Tenofovir distribuída pelo SUS. Embora essa combinação ainda não seja produzida no Brasil, a Fundação Oswaldo Cruz (Fiocruz), vinculada ao Ministério da Saúde, anunciou recentemente um acordo  visando sua fabricação.</p>
<p>Por outro lado, alguns laboratórios nacionais produzem um medicamento que já foi apontado como equivalente pela Organização Mundial de Saúde (OMS). Trata-se da associação entre Lamivudina e Tenofovir. No Brasil, porém, a combinação desses dois fármacos não é usada para a PrEP, o que poderá ocorrer com o aprofundamento dos estudos. Por outro lado, ela é geralmente prescrita para mães grávidas soropositivas, pois atua para impedir a transmissão do vírus ao bebê. Também é indicado no tratamento da Aids para pacientes em geral e ainda como Profilaxia Pós-Exposição ao HIV (PEP), que consiste no uso da medicação em até 72 horas após situação em que exista risco de infecção.</p>
<p>"Existem trabalhos internacionais que mostram que o Tenefovir sozinho funciona tão bem quanto associado à Emtricitabina ou à Lamivudina", conta infectologista e professor da UFMG, Dirceu Grego, coordenador do estudo. Ele explica, porém, que a pesquisa da UFMG se classifica como estudo clínico de fase 2, que avaliará a segurança e aceitabilidade da medicação. A eficácia é analisada com mais detalhamento na fase 3, que envolve um número maior de pessoas, embora algumas sinalizações já possam ser observadas na fase 2.</p>
<p>A pesquisa da UFMG conta o financiamento do Ministério da Saúde e poderá dar segurança para que o governo brasileiro, no futuro, opte por usar como PrEP o medicamento baseado na associação entre Lamivudina e Tenefovir, que já conta com versões nacionais. Mesmo que o custo das duas pílulas seja semelhante, já que a indústria estrangeira tem condições de baixar o preço e enfrentar a concorrência nacional, Dirceu Greco considera que há algumas vantagens quando se compra o medicamento do país.</p>
<p>"A indústria brasileira paga impostos no Brasil, gera emprego e renda, os trabalhadores que são pagos moram no país. Então existe esse argumento. Talvez não se economize tanto no custo do medicamento, mas ao estimular a indústria nacional há vários efeitos secundários na economia nacional. Mas pode acontecer da indústria internacional baixar significativamente o preço. Aí não tem jeito. Provavelmente, o governo vai comprar lá fora", avalia o infectologista.</p>
<p>Outra consequência de uma comprovação segura da equivalência das duas associações, segundo ele, seria o impacto mundial. Em sua visão, se o governo brasileiro optar um dia por usar a associação de Lamivudina e Tenefovir e mostrar na prática essa equivalência, outros países que não têm a produção do medicamento terão novos elementos para negociar um preço melhor junto à indústria internacional.</p>
<p>O estudo também pretende observar aspectos vinculados ao comportamento e ao contexto sociocultural. O objetivo é produzir conhecimento a partir da realidade local, subsidiando a estruturação de políticas públicas e de campanhas em saúde. Em alguns países, por exemplo, pesquisas mostraram que as pessoas não passaram a usar menos camisinha por usarem PrEP. Para Dirceu Grego, a pílula traz vantagens, mas deve ser encarada como um método a mais e não como método alternativo. Ele reconhece, porém, que algumas pessoas podem negociar riscos e decidir usá-la em substituição ao preservativo.</p>
<p>"A prevenção ao HIV, teoricamente, é simples: se todos usassem preservativo, não haveria mais transmissão nem do HIV e nem das demais DSTs. Mas na prática não é assim. Se fosse, já teríamos colocado fim à epidemia. Mas a sexualidade não é algo mecânico. A tomada de decisão sobre o risco é algo complexo que envolve, entre diversos fatores, diferenças sociais, questões de acesso, aspectos culturais de um país machista como o nosso. Numa relação heterossexual, geralmente quem mais influi na decisão sobre usar um método de barreira é o homem", diz o infectologista.</p>
<p>Para ele, há também aspectos de ordem psicológica e discussões complexas, entre elas qual a definição de prazer sexual. Os pesquisadores da UFMG se propõem ainda a monitorar os efeitos colaterais e os eventos adversos e saber se, nesse aspecto, há diferença entre os dois medicamentos. Irão medir também a qualidade de vida dos voluntários e observar, por exemplo, o desenvolvimento de ansiedade e estresse decorrente do esforço e do compromisso diário de se tomar a pílula.</p>
<p>"Tomar um medicamento diariamente não é algo trivial. Como uma pessoa que não possui HIV vai lidar com a situação de levar na carteira ou na bolsa um frasco de comprimidos contra o vírus?" questiona Dirceu Grego. A dificuldade de garantir adesão constante ao preservativo também pode se repetir com a pílula, o que é outra preocupação, sobretudo porque é essencial a disciplina do uso diário do medicamento.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 16:15:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae0da398ddf0.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[5 celulares que já foram top de linha e agora custam menos de R$ 2 mil]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587360/5-celulares-que-ja-foram-top-de-linha-e-agora-custam-menos-de-r-2-mil?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587360/5-celulares-que-ja-foram-top-de-linha-e-agora-custam-menos-de-r-2-mil?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Modelos premium ainda representam boas opções de compra]]></description>
                                            <content:encoded><![CDATA[<p>Com a chegada de novas versões de smartphones, é normal que os "ex-tops de linha" fiquem mais baratos. Assim, celulares como o iPhone 6s - o carro-chefe da Apple em 2015 - agora custam menos de R$ 2 mil.</p>

<p>O Techtudo preparou uma lista com seis modelos nesta faixa de preço. Confira:</p>
<p><span class="news_bold">Galaxy S7</span></p>
<p>Quando foi lançado, no início de 2016, o modelo da Samsung custava R$ 3.799. Agora, ele pode ser encontrado em sites por pouco menos de R$ 1.600. O smartphone conta com armazenamento interno de 32 GB e memória RAM de 4 GB. A câmera traseira é de 12 megapixels e a frontal de 5 megapixels.</p>
<p><span class="news_bold">iPhone 6S</span></p>
<p>O premium da Apple chegou ao Brasil em 2015, quando custava cerca de 3.999 no modelo de 16 GB. Em 2018, esta versão pode ser encontrada por aproximadamente R$ 1.400. Assim como o Galaxy S7, o celular possui câmera traseira de 12 megapixels e frontal de 5 megapixels. A memória RAM é de 2 GB e seu processador é o Apple A9 - dual-core de 1,8 GHz.</p>
<p><span class="news_bold">Moto Z</span></p>
<p>O Moto Z, que custava R$ 3.199 em 2016, pode ser encontrado hoje por cerca de R$ 1.900 em lojas online. Possui processador Snapdragon 820 (quad-core de 1,8 GHz), memória RAM de 4 GB e armazenamento interno de 64 GB.</p>
<p><span class="news_bold">iPhone SE</span></p>
<p>O modelo conquistou os amantes de desings antigos da Apple. A versão de 32 GB começou a ser vendida no Brasil por R$ 2.499. Hoje, o mesmo aparelho custa cerca de R$ 1.400. A câmera traseira é de 12 megapixels, mas a frontal é de apenas 1.2 megapixels - o que pode ser uma péssima notícia para quem ama tirar selfies.</p>
<p><span class="news_bold">Xperia Z5</span></p>
<p>O preço de lançamento do destaque da Sony, em 2015, era de R$ 4.299. Segundo a reportage, brasileiros já podem encontrar o modelo por pouco menos de R$ 1.500. O processador é o Snapdragon 810 (octa-core de até 2 GHz). Ele possui memória RAM de 3 GB e 32 GB de armazenamento interno. Quando as câmeras, o sensor traseiro é de 23 megapixels e o frontal, de 5 megapixels.</p>
<p> </p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 15:27:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aef48c8a105e.jpg?1525631253" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Ação judicial trava uso de satélite brasileiro que custou R$ 2,7 bi]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587299/acao-judicial-trava-uso-de-satelite-brasileiro-que-custou-r-2-7-bi?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587299/acao-judicial-trava-uso-de-satelite-brasileiro-que-custou-r-2-7-bi?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Processo envolvendo empresa de comunicação e Telebras travam projeto bilionário]]></description>
                                            <content:encoded><![CDATA[<p>O satélite brasileiro lançado para distribuir sinal de banda larga acaba de completar um ano em órbita, nessa sexta-feira (4). No entanto, não há motivo para comemorações. Até o momento, o investimento de R$ 2,78 bilhões levou internet a menos de 0,1% dos locais planejados inicialmente. O projeto tem esbarrado em uma briga judicial entra a Telebras e empresas de telecomunicações.</p>

<p>Como explica o G1, o Satélite Geoestacionário de Defesa e Comunicações Estratégicas (SGDC) é fruto de um parceria entre o Ministério da Defesa e a Telebras. O Exército usa 30% da capacidade do equipamento para conectar instalações, como postos da fronteira. Enquanto a empresa de capital misto usa o restante para fornecer conexão contratada por órgãos do governo federal.</p>
<p>O projeto previa que a Telebras contratasse uma empresa para instalar a infraestrutura de rede em todo o Brasil. Em troca, ela poderia usar a capacidade disponível para ofertas os seus próprios serviços de banda larga.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587261/chegou-a-hora-de-abandonar-o-whatsapp-diz-o-new-york-times" target="_blank">+ Chegou a hora de abandonar o WhatsApp, diz o New York Times</a></p>
<p>Após firmar contrato com a empresa norte-americana Viasat, que até então não atuava no país, era esperado que 8 mil postos foram instalados até o fim do ano e 15 mil até março de 2019.</p>
<p>“Com o contrato assinado, a gente começou a ativar os primeiros pontos. Tínhamos 500 pontos para ativar em abril. Conseguimos fazer 4”, explicou ao G1 o presidente da Telebras, Jarbas Valente. Os pontos instalados são três escolas e um ponto de fronteira.</p>
<p>Segundo Valente, o prejuízo começou neste momento e já atingiu R$ 100 milhões. Como em maio a previsão era levar conexão a outros 1 mil pontos, as perdas passaram a ser de R$ 800 mil por dia.</p>
<p>Contudo, no fim de março, a empresa Via Direta Telecomunicações conseguiu na Justiça do Amazonas uma liminar para suspender o acordo entre Telebras e Viasat. A companhia amazonense alega ter sido preterida do processo depois de iniciar as negociações para operar parte da capacidade do satélite. A soberania do Brasil também foi questionada, já que uma empresa estrangeira operaria um satélite que também atende o Exército brasileiro.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 11:29:17 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aef11b32e88b.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Chegou a hora de abandonar o WhatsApp, diz o New York Times]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587261/chegou-a-hora-de-abandonar-o-whatsapp-diz-o-new-york-times?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587261/chegou-a-hora-de-abandonar-o-whatsapp-diz-o-new-york-times?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Saída do fundador Jan Koum é negativo para o app de mensagens]]></description>
                                            <content:encoded><![CDATA[<p>Cofundador do WhatsApp, Jan Koum anunciou a própria saída não só da empresa responsável pelo app de mensagens como também do conselho de administração do Facebook. Conforme o New York Times, a decisão é um duro baque e pode sinalizar um momento de apagar o mensageiro.</p>

<p>Fontes do Facebook citadas pelo jornal norte-americano revelam que Koum estava cada vez mais preocupado com a forma como a tecnologia recolhe dados dos usuários. A ideia dele era afastar o WhatsApp deste cenário.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587209/hacker-que-combate-fake-news-usa-a-propria-avo-como-ferramenta">+ Hacker que combate fake news usa a própria avó como ferramenta</a></p>
<p>A publicação alerta ainda que os membros do conselho do Facebook não se preocupam com questões de segurança e privacidade, e os colaboradores do WhatsApp temem que o aplicativo seja usado para recolher ainda mais dados.</p>
<p>Durante a gestão de Koum, o WhatsApp compartilhou poucos dados com o Facebook, mas, com a saída dele, é provável que o Facebook tenha mais facilidade para reunir mais informações sobre os usuários, denuncia o jornal. Conforme dados de 2017, o WhatsApp tem 1,5 bilhão de usuários ativos - que  trocam cerca de 60 bilhões de mensagens diárias.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 08:48:49 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aeeebdebd0d5.jpg?1525607512" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Filtro de vídeos do YouTube mobiliza pais]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587244/filtro-de-videos-do-youtube-mobiliza-pais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587244/filtro-de-videos-do-youtube-mobiliza-pais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Para Milc, o ideal seria que o governo ou o próprio YouTube fizesse uma "curadoria" de canais com co]]></description>
                                            <content:encoded><![CDATA[<p>Diante de vídeos que consideram inadequados, como publicidades incisivas e promoção de desafios perigosos, pais e mães têm dificuldades de monitorar o que os filhos veem no YouTube. O comentário em uma postagem do Movimento Infância Livre de Consumismo (Milc), com sugestões de canais adequados para crianças, resume esse receio: "Parece que quanto mais bloqueio mais opções aparecem". Por isso, famílias e associações criam estratégias diversas para filtrar o que os filhos acessam. O Ministério da Justiça não prevê a criação de uma classificação indicativa para o conteúdo virtual no País.</p>

<p>As críticas envolvem, principalmente, vídeos de "unboxing" (abertura de presentes ou embalagens, para fazer publicidade do produto), consumo de guloseimas e desafios considerados perigosos. O Milc, criado por três mães em 2012, faz campanhas e mobilizações contra o consumismo na internet e pretende reunir dicas de páginas virtuais adequadas.</p>
<p>Para o movimento, o ideal seria que o governo ou o próprio YouTube fizesse uma "curadoria" de canais com conteúdo para crianças e adolescentes e classificá-los por faixa etária. Segundo a publicitária Mariana Sá, de 40 anos, uma das criadoras do Milc, boicotar a tecnologia é utópico. "Aí vai fazer o quê? Levar para o mato?"</p>
<p>Para Mariana, por mais que os pais tentem fugir, o envolvimento é quase inevitável. "O mecanismo da 'zoeira' dos youtubers é o mesmo que causa fascínio dos adultos por pegadinhas e videocassetadas", diz.</p>
<p>Para Pedro Hartung, advogado do Instituto Alana, o YouTube deveria adotar um sistema automático de classificação indicativa com base em informações oferecidas pelos canais. Hoje, o conteúdo para maiores de 18 anos só é acessível por meio de login que comprove a idade.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587209/hacker-que-combate-fake-news-usa-a-propria-avo-como-ferramenta" target="_blank">+ Hacker que combate fake news usa a própria avó como ferramenta</a></p>
<p>Dos cem canais brasileiros com mais visualizações, 52 são produzidos para crianças de até 12 anos, segundo levantamento de 20 de abril, feito pela coordenadora do ESPM Media Lab, Luciana Corrêa. Na mesma data, seis dos dez mais populares eram focados nessa faixa etária. Os 500 mais vistos pelo mesmo público ultrapassam 117 bilhões de visualizações.</p>
<p>Segundo ela, um fenômeno recente é a mudança de conteúdo para acompanhar o amadurecimento do público. "Essa geração que cresceu assistindo 'unboxing' e Galinha Pintadinha já está no 'teen', que é a categoria que mais cresce", aponta.</p>
<p>Um exemplo é Pedro Lopes, de 21 anos, que lançou o canal RezendeEvil em 2012, com foco no jogo Minecraft. Hoje, seus vídeos são focados principalmente em gincanas e pegadinhas (as "trolladas") entre jovens, enquanto o conteúdo sobre o jogo fica no canal RezendeEvil Minecraft - lançado há um ano, mesma época em que criou o Canal do Rezendinho. Juntos, somam 6 bilhões de visualizações.</p>
<p>Nesse cenário, surgiram dois perfis distintos entre o público infantojuvenil: youtubers mirins que copiam trejeitos de adultos e adultos que agem de modo infantilizado. Mas, para Luciana, não é uma novidade: "a Xuxa era uma figura adulta com voz infantilizada, não muito diferente do que há hoje".</p>
<p>Influencers. Anônimos para adultos, youtubers como Christian Figueiredo, Julio Cocielo e as gêmeas Melissa e Nicole colecionam milhões de seguidores. "São o que os atores de cinema e televisão já foram", exemplifica o diretor de Educação da ONG Safernet, Rodrigo Nejm.</p>
<p>Por isso, fazem jus ao termo "influencer" (influenciador, seja em comportamento, classe social ou aparência, pontua Nejm). "Apesar de haver algo danoso na reprodução de modelos idealizados, o YouTube também é uma plataforma de outros modelos alternativos, outras visões de mundo."</p>
<p>Ele defende a importância de conhecer canais e incentivar os filhos a fazerem uma "leitura crítica" do que assistem. "É um equívoco achar que as novas gerações dominam todas as tecnologias. O fato de usar muito não significa que a criança tem condições de usar de forma crítica, segura, consciente", opina.</p>
<p>Para Nejm, a criança precisa ter noções de "autocuidado". "Se a criança não tiver noção do que existe e não deve acessar, quando tiver 9, 10 anos e tiver acesso a um celular vai ficar muito vulnerável", diz.</p>
<p>Pais atentos. A blogueira do canal Bagagem de Mãe, Loreta Berezutchi, de 34 anos, só deixa os filhos, Pedro, de 10 anos, e Catarina, de 8, assistirem aos canais que analisou. "Tudo passa pelo meu crivo. Faço desde tão cedo que hoje, se não estiver junto, eles perguntam se podem."</p>
<p>Criador do site NerdPai, Jorge Freire, de 45 anos, criou uma lista dos canais proibidos e dos seguros para os filhos Leonardo, de 8, e Bruna, de 2. "É preciso estar atento e criar camadas de proteção. Se não, essa molecada consegue burlar fácil."</p>
<p>Alda Elizabeth Azevedo, da Sociedade Brasileira de Pediatria, diz que o acesso de crianças de até 2 anos à internet deve ser evitado "ao máximo" e, até 5 anos, a até uma hora diária. "Não dá para fazer da tela uma babá. A criança nessa fase está em pleno desenvolvimento neurológico, cognitivo, precisa de mais estímulos."</p>
<p>Além disso, entidades criticam a publicidade embutida em vídeos. "A TV é mais fácil, tem marcadores específicos, como o intervalo. No YouTube, essa identificação é mais difícil até para adultos. Ainda mais porque há conteúdos que são uma espécie de publicidade, como vídeos em lojas ou mostrando maquiagens", diz a coordenadora do estudo TIC Kids Online Brasil, Maria Eugenia Sozio.</p>
<p>Regulação. Diante das críticas, o YouTube anunciou para este ano mudanças no YouTube Kids, plataforma destinada ao público infantil. Dentre elas, estão a criação de um acervo "confiável", com conteúdo de artes e esportes, e um recurso para os pais bloquearem conteúdos que considerarem impróprio.</p>
<p>"Sempre recomendamos que os pais acessem o YouTube em conjunto com seus filhos e oferecemos recursos para navegar na plataforma com segurança", informou, em nota. "Quando somos informados de uma conta que pertence a alguém que é menor de idade, encerramos o cadastro de acordo com nossas diretrizes. Não nos interessa ter conteúdo que viole as nossas políticas em nossa plataforma."</p>
<p>O tema também preocupa fora do País. Em abril, o ministro de Saúde do Reino Unido, Jeremy Hunt, afirmou que o governo deve criar novas leis de regulação online para gigantes da internet, como o Google, caso elas não promovam ações de uso saudável da rede por crianças e adolescentes. Com informações do Estadão Conteúdo.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Estadao Conteudo</dc:creator>
                    <pubDate>Sun, 06 May 2018 08:14:05 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5acb2f775cd7e.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Hacker que combate fake news usa a própria avó como ferramenta]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587209/hacker-que-combate-fake-news-usa-a-propria-avo-como-ferramenta?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587209/hacker-que-combate-fake-news-usa-a-propria-avo-como-ferramenta?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Norte-americana de 86 anos segue mais de 1.400 páginas - a grande maioria de notícias falsas]]></description>
                                            <content:encoded><![CDATA[<p>Quando começou a desenvolver um sistema para detectar desinformação nas redes sociais, o jornalista e programador norte-americano Cameron Hickey não sabia que uma das principais ferramentas para encontrar o que chama de "junk news" seria uma senhora de 86 anos que vive no interior dos Estados Unidos: a própria avó.</p>

<p>"Foi perturbador, não pelo fato de ela curtir essas páginas, mas pelo fato de haver tantas", afirma Hickey à reportagem. A aposentada Betty Manlove segue mais de 1.400 páginas no Facebook - boa parte delas é fonte de desinformação como a Cosmo Política e a Manchete Diária.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/587184/nova-pegadinha-trava-whatsapp-com-mensagem-de-caracteres-invisiveis">+ Nova 'pegadinha' trava WhatsApp com mensagem de caracteres invisíveis</a></p>
<p>Três delas, como descobriram, foram criadas por agentes russos nas eleições americanas de 2016. E muitas ela nem sequer lembrava de ter curtido (provavelmente após ter clicado em algum anúncio).</p>
<p>Entender esse ecossistema de junk news e como a desinformação se espalha pelas redes é o objetivo do NewsTracker, ferramenta criada por Hickey e que deve ser replicada em outros países, inclusive no Brasil.</p>
<p>"É muito mais do que notícia falsa: inclui hiperpartidarismo, clickbait, plágio, informação enganosa, memes, sátiras." Uma visita aos sites curtidos pela avó do jornalista, que integram a base de dados do NewsTracker, ajuda a entender esse ecossistema.</p>
<p>Notas sobre a família real se mesclam a notícias urgentes, sobre temas do momento, mas baseadas em falsas premissas ou informações não confirmadas. Entre as chamadas: "Acontecendo agora: México em pânico" ou "Curta e compartilhe se você gosta da nossa primeira-dama".</p>
<p>Manlove é cristã e conservadora, eleitora de Donald Trump –o que não quer dizer que o universo das junk news se restrinja a esse público. Páginas de cunho liberal, que atacam o presidente republicano, também distribuem conteúdo falso e hiperpartidário. Uma das maiores é o Truth Examiner, seguido por 3,8 milhões de pessoas.</p>
<p>"Curta se você NUNCA vai apoiar Donald Trump!", diz a página de abertura, repleta de chamadas como "Quando os conservadores vão perceber que as ARMAS são o problema??" ou "Veja a professora que enganou Trump".</p>
<p>As táticas são as mesmas. As chamadas alimentam a raiva e incitam a divisão política. Muitos dos sites saem do ar depois de um tempo, criando novos domínios na sequência, para evitar que sejam detectados por algoritmos que bloqueiam conteúdo falso ou extremista.</p>
<p>São táticas que se replicam pelo mundo. Hickey aposta, por exemplo, que a estratégia dos sites americanos foi copiada por russos e macedônios que tentaram influenciar a eleição dos EUA. No topo da lista de junk news, o compartilhamento das páginas chega a ser maior que o do New York Times.Isso não quer dizer que os leitores aceitem o conteúdo de forma passiva ou ingênua.</p>
<p>A avó de Hickey, por exemplo, se demonstrou cética em relação ao que lê no Facebook – mas disse que não ia mudar seus princípios nem deixar de curtir as páginas."Ela nutre um grande ceticismo em relação à mídia tradicional. É muito mais provável que ela prefira menosprezar a relevância das junk news, ou ignorá-las, em vez de parar de segui-las", comenta Hickey.</p>
<p>A reportagem pediu para entrevistar Betty, mas ela declinou. Em entrevista a TV dos EUA, disse ter ficado aborrecida pela exposição a conteúdo russo, mas afirmou que continuará fiel aos seus princípios."Isso mostra que há uma questão maior e que envolve todos nós: a fidelidade ao que acreditamos", diz o jornalista.</p>
<p>Hickey afirma ainda que pretende expandir o NewsTracker para outros países. Um dos alvos é o Brasil, onde ele afirma haver um grande "buraco negro" de desinformação no WhatsApp, cujas informações são protegidas por criptografia.</p>
<p>Há, segundo ele, conversas em andamento para desenvolver um protótipo no país, em parceria com organizações jornalísticas. Com informações de Estelita Hass Carazzai, da Folhapress. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Folhapress</dc:creator>
                    <pubDate>Sun, 06 May 2018 06:11:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aeec9b90fcd9.jpg?1525598705" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Nova 'pegadinha' trava WhatsApp com mensagem de caracteres invisíveis]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587184/nova-pegadinha-trava-whatsapp-com-mensagem-de-caracteres-invisiveis?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587184/nova-pegadinha-trava-whatsapp-com-mensagem-de-caracteres-invisiveis?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Problema afeta usuários do sistema Android]]></description>
                                            <content:encoded><![CDATA[<p>Usuários do sistema Android devem ficar atentos sobre uma mensagem com caracteres invisíveis que trava aplicativos por segundos, entre eles o WhatsApp. O problema não afeta o sistema iOS.</p>

<p>No Brasil, parece que este caso está circulando pelo WhatsApp. De acordo com o TecMundo, é preciso convencer um usuário a tocar em uma mensagem que tem mais de 2 mil caracteres invisíveis para que o aplicativo trave.</p>
<p><img class="tinymceimage img-responsive" src="http://static.noticiasaominuto.com.br/stockimages/gallery/640/naom_5aee4a049daf5.jpg" border="0" alt="Notícias ao Minuto" width="446" height="269" /></p>
<p>Em alguns casos, os usuários precisam reiniciar o aplicativo para que a plataforma volte a funcionar. Embora haja este pequeno inconveniente, a "pegadinha" não traz efeitos mais graves ao celular.</p>
<p> Leia também:<a href="https://www.noticiasaominuto.com.br/tech/587162/chuva-de-meteoros-do-cometa-halley-atingira-a-terra-nesta-madrugada" target="_blank"> Chuva de meteoros do cometa Halley atingirá a Terra nesta madrugada</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 06 May 2018 05:44:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aee496109a40.jpg?1525566084" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Chuva de meteoros do cometa Halley atingirá a Terra nesta madrugada]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587162/chuva-de-meteoros-do-cometa-halley-atingira-a-terra-nesta-madrugada?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587162/chuva-de-meteoros-do-cometa-halley-atingira-a-terra-nesta-madrugada?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Espetáculo poderá ser observado a olho nu]]></description>
                                            <content:encoded><![CDATA[<p>Admiradores de fenômenos naturais têm um motivo a mais para ficar acordados na madrugada deste domingo (6), entre as 2h e as 5h – horário de Brasília. Uma chuva de meteororitos poderá ser vista a olho nu. O espetáculo na atmosfera é causado por um rastro de detritos deixado pelo Cometa Halley em sua última aparição há 32 anos. Em outubro, ocorrerá outro fenômeno semelhante.</p>

<p> A próxima aparição do Cometa Halley na Terra será em 2061. Halley, o cometa, passa no sistema solar da Terra a cada 76 anos. Para observar o céu neste domingo, não será necessário utilizar aparelhos, bastar olhar para onde nasce o sol. O ideal é escolher locais sem interferência de luzes artificiais. O fenômeno denominado “chuva de meteoritos” ocorre porque o calor do sol faz com que o cometa solte aderência gelada.</p>
<p>+<a href="https://www.noticiasaominuto.com.br/tech/587122/siri-cortana-alexa-ou-google-assistente-qual-e-a-melhor-ajudante" target="_blank"> Siri, Cortana, Alexa ou Google Assistente: qual é a melhor ajudante?</a></p>
<p>Na prática, a cada passagem do Halley perto do sol, o cometa lança um novo rastro de detritos em seu fluxo orbital, perdendo massa. Esses fragmentos são mínimos (os meteoritos) e podem ser comparados ao tamanho de grãos de areia ou de cascalho. Mas em grande quantidade provocam um espetáculo no céu como se fosse uma explosão de pequenos raios. Em outubro, será possível ver novamente um espetáculo semelhante pois a cada seis meses, a Terra intercepta o caminho orbital do Cometa Halley. Com informações da Agência Brasil. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 20:30:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ada7ed625a44.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Novo Vine é adiado por questões financeiras e judiciais]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587167/novo-vine-e-adiado-por-questoes-financeiras-e-judiciais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587167/novo-vine-e-adiado-por-questoes-financeiras-e-judiciais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Por enquanto, lançamento da plataforma não tem nova data]]></description>
                                            <content:encoded><![CDATA[<p>O lançamento de uma nova versão do Vine foi confirmado no início deste ano. Apesar do entusiasmo que a notícia gerou aos fãs da rede, parece que as coisas não vão bem.</p>

<p>Segundo o TecMundo, o criador do Vine, Dom Hoffman, publicou um texto por meio do Twitter dizendo que a novidade precisou ser adiada por tempo indeterminado. Ele diz que "subestimou a quantidade de entusiasmo e atenção que o anúncio [do ressurgimento da rede social] geraria". Com tamanha expectativa, os desenvolvedores precisariam criar uma plataforma muito mais robusta e, por isso, "os custos estimados apenas para os primeiros meses seriam muito altos".</p>
<p>+<a href="https://www.noticiasaominuto.com.br/tech/587162/chuva-de-meteoros-do-cometa-halley-atingira-a-terra-nesta-madrugada" target="_blank"> Chuva de meteoros do cometa Halley atingirá a Terra nesta madrugada</a></p>
<p>Hoffman também citou questões judiciais na produção, sem especificar quais. "Resumindo a história, para funcionar, o projeto V2 precisa operar como uma companhia, com financiamento externo escalável, provavelmente de investidores", explicou.</p>
<blockquote class="twitter-tweet" data-lang="pt">
<p dir="ltr" lang="en">the v2 project is postponed <a href="https://t.co/H0e9e0BTdg">https://t.co/H0e9e0BTdg</a> <a href="https://t.co/mN5wIbdQsf">pic.twitter.com/mN5wIbdQsf</a></p>
— v2 (@v2app) <a href="https://twitter.com/v2app/status/992442912377106432?ref_src=twsrc%5Etfw">4 de maio de 2018</a></blockquote>
<p>
<script charset="utf-8" src="https://platform.twitter.com/widgets.js" async=""></script>
</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 19:48:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_58871c6fb9b93.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Siri, Cortana, Alexa ou Google Assistente: qual é a melhor ajudante?]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587122/siri-cortana-alexa-ou-google-assistente-qual-e-a-melhor-ajudante?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587122/siri-cortana-alexa-ou-google-assistente-qual-e-a-melhor-ajudante?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Uma pesquisa do Stone Temple revela qual delas apresenta o melhor desempenho]]></description>
                                            <content:encoded><![CDATA[<p>O avanço da inteligência artificial tem tornado as ajudantes pessoais das gigantes tecnológicas cada vez mais úteis e necessárias no dia a dia. Entre as mais famosas estão Alexa, Cortana, Google Assistente e a Siri. Mas qual delas é melhor?</p>

<p>Uma pesquisa do site Stone Temple, feita no início deste mês, procurou responder esta pergunta. Segundo a agência, o <span class="news_bold">Google Assistente</span> representa o melhor desempenho da inteligência artificial. A tecnologia é capaz de aceitar cerca de 80% das perguntas, acertando 9 respostas a cada 10 perguntas.</p>
<p>De acordo com o site 'TecMundo', a Cortana, assistente da Microsoft, ocupa a segunda posição do ranking e a Alexa, da Amazon, ficou em terceiro.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/587050/lancamento-e-bem-sucedido-e-sonda-insight-esta-a-caminho-de-marte" target="_blank">Lançamento é bem-sucedido, e Sonda InSight está a caminho de Marte</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 17:24:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_56125a76d4d4c.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Lançamento é bem-sucedido, e Sonda InSight está a caminho de Marte]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587050/lancamento-e-bem-sucedido-e-sonda-insight-esta-a-caminho-de-marte?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587050/lancamento-e-bem-sucedido-e-sonda-insight-esta-a-caminho-de-marte?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Missão vai estudar a estrutura interna do planeta vermelho]]></description>
                                            <content:encoded><![CDATA[<p>O lançamento da sonda InSight foi bem-sucedido, e a espaçonave da Nasa já está a caminho de Marte, onde deve tentar realizar um pouso em novembro, para estudar a estrutura interna do planeta vermelho.</p>

<p>O foguete Atlas V-401 teve desempenho exemplar, a despeito de alguns alertas de anomalias de telemetria poucos minutos antes da decolagem. O voo começou exatamente na abertura da janela, às 8h05 (de Brasília) do sábado (5). Após cerca de 60 minutos numa órbita terrestre baixa, o motor do segundo estágio colocou a sonda em sua trajetória interplanetária.</p>
<p>Foi um voo histórico: o primeiro lançamento de uma sonda interplanetária da Nasa a partir da Base Aérea de Vandenberg, na Califórnia. Até então, todos os lançamentos do tipo haviam sido feitos da Flórida, local mais propício para esse perfil de missão.</p>
<p>A opção por Vandenberg foi logística -havia menos disponibilidade na plataforma para cobrir os pouco mais de dois meses da janela de lançamento para Marte, que ia de 5 de maio a 8 de junho.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/586990/iphone-7-e-7-plus-alguns-aparelhos-estao-com-falha-no-microfone" target="_blank">+ iPhone 7 e 7 Plus: alguns aparelhos estão com falha no microfone</a></p>
<p>Ao longo dos próximos seis meses, a InSight deve fazer uma série de pequenas correções de curso para chegar a seu destino final, em Elysium Planitia, na região equatorial de Marte.</p>
<p>A missão desta vez não envolve um jipe robótico, mas um módulo de pouso estacionário, que colocará diversos instrumentos na superfície de Marte. Um sismômetro medirá "martemotos" -terremotos marcianos- e com isso será capaz de investigar a estrutura interna do planeta vermelho.</p>
<p>Uma perfuratriz fará uma penetração a até 5 metros de profundidade para medir quanto calor ainda flui do interior de Marte para a superfície. Câmeras ajudarão a medir oscilações no eixo de rotação marciano ao longo de sua órbita em torno do Sol.</p>
<p>Por fim, uma estação meteorológica medirá ventos e temperatura na atmosfera marciana no local de pouso.</p>
<p>Tudo isso, claro, se o pouso for bem-sucedido.</p>
<p><span class="news_bold">HERANÇA TECNOLÓGICA</span></p>
<p>A espaçonave em si é fortemente baseada na Phoenix, módulo de pouso que desceu próximo ao polo Norte de Marte em 2008. "Algumas das peças inclusive foram reaproveitadas daquela missão", diz Ramon de Paula, engenheiro brasileiro que trabalha no Quartel-General da Nasa como executivo de programa da missão.</p>
<p>Apesar dessa similaridade, pousar em Marte é sempre difícil, e o fato de ter dado certo em 2008 não quer dizer que vá sair tudo bem agora. "A probabilidade de sucesso é a mesma da que tinha a Phoenix, porque há outros fatores em jogo."</p>
<p>Com efeito, enquanto a Phoenix desceu proximo a um polo, a InSight vai para uma região colada ao equador marciano, em Elysium Planitia. A nova nave é um pouco mais pesada, vem em velocidade maior e terá menos atmosfera para ajudar na frenagem com para-quedas, uma vez que a área de pouso da InSight tem altitude cerca de 1.500 metros maior que a da Phoenix.</p>
<p>Apesar dos desafios, há grande confiança de que a missão será bem-sucedida. "As estimativas são da ordem de 99,8%, 99,9%", diz De Paula.</p>
<p>Para monitorar a descida, dois minissatélites, MarCO A e B, foram lançados junto com a InSight. Além de tentar captar o sinal da InSight durante o pouso e retransmiti-lo para a Terra, a dupla testará a tecnologia de cubesats de baixo custo para missões interplanetárias.</p>
<p>O custo total da missão é de US$ 829 milhões. Com informações da Folhapress.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Folhapress</dc:creator>
                    <pubDate>Sat, 05 May 2018 13:46:04 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aede0585bfb3.jpg?1525538983" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Garoto de 11 anos já desenvolveu sete apps para iPhone]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585895/garoto-de-11-anos-ja-desenvolveu-sete-apps-para-iphone?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585895/garoto-de-11-anos-ja-desenvolveu-sete-apps-para-iphone?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Yuma Soerianto começou a programar com apenas seis anos de idade; seu game mais recente integra Real]]></description>
                                            <content:encoded><![CDATA[<p>Cansado de ver televisão, um menino australiano de apenas 11 anos, Yuma Soerianto, já desenvolveu sete aplicativos disponibilizados na App Store, a loja virtual da Apple.</p>

<p>"Comecei a programar com seis anos. Voltei da escola e geralmente via televisão, mas eram repetições e eu odeio repetições. São chatas. Quis fazer algo mais do que ver televisão", explica Soerianto em conversa com o Cnet.</p>
<p>Começando a partir de pequenos tutoriais e da construção do seu próprio site, Soerianto passou a desenvolver jogos para navegadores de internet e, pouco depois, criou os <a href="https://itunes.apple.com/us/developer/hendri-soerianto/id1107831294?mt=8" target="_blank">apps disponíveis na App Store</a>.</p>
<p>Agora, o garoto já está desenvolvendo apps em Realidade Aumentada. No mais recente deles, chamado ‘Let’s Stack AR!’, os jogadores devem ajudar um pato a empilhar blocos 3D.</p>
<p>O garoto também mantém o seu próprio canal de YouTube, o <a href="https://www.youtube.com/channel/UCuCWFtFqtR-OzqL1lLcdLXw/featured" target="_blank">Anyone Can Code</a>, no qual procura encorajar e ensinar outras pessoas a começarem a programar.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 13:38:11 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aeae479866a8.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Messi aparece como Super Saiyajin em vídeo; veja]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587038/messi-aparece-como-super-saiyajin-em-video-veja?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587038/messi-aparece-como-super-saiyajin-em-video-veja?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Campanha faz parte da divulgação da Copa pelo canal Fox; a Toei Animation respondeu]]></description>
                                            <content:encoded><![CDATA[<p>Lionel Messi é a estrela de uma campanha lançada no Twitter da Fox Soccer. O vídeo que divulga a Copa do Mundo da Rússia traz o craque argentino na pele de Super Saiyajin Blue. "Um momento que três milhões de pessoas estarão acompanhando... mais importante do que a chegada à Lua", diz trecho do vídeo.</p>

<p>"Se ele erra, ele ainda é o Messi. Mas se acerta, é o Messias", narra parte que antecede um gol do jogador pela Seleção da Argentina, no mundial passado. "Neste verão, homens se tornarão deuses. E o mundo se transformará na Copa do Mundo", diz o canal no Twitter, como legenda do vídeo.</p>
<p><span class="news_bold"><a href="https://www.noticiasaominuto.com.br/tech/587022/ja-mudou-a-senha-do-twitter-entao-corra-e-mais-seguro" target="_blank">+ Já mudou a senha do Twitter? Então, corra, é mais seguro</a></span></p>
<p>A brincadeira não passou despercebida: a Toei Animation, criadora do anime "Dragon Ball", aproveitou para responder com um gif de Goku com a legenda: "Neste verão, homens podem ser Super Saiyajins".  Veja.</p>
<blockquote class="twitter-tweet" data-lang="en">
<p dir="ltr" lang="en">Will Messi finally cement his legacy?This summer, men become gods. And the world becomes the World Cup. <a href="https://t.co/WtUTlx4bZN">pic.twitter.com/WtUTlx4bZN</a></p>
— FOX Soccer (@FOXSoccer) <a href="https://twitter.com/FOXSoccer/status/991469819949125633?ref_src=twsrc%5Etfw">May 2, 2018</a></blockquote>
<p>
<script charset="utf-8" src="https://platform.twitter.com/widgets.js" async=""></script>
</p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 12:56:43 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aedd45b83415.jpg?1525535878" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Já mudou a senha do Twitter? Então, corra, é mais seguro]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/587022/ja-mudou-a-senha-do-twitter-entao-corra-e-mais-seguro?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/587022/ja-mudou-a-senha-do-twitter-entao-corra-e-mais-seguro?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Microblog teve falha de segurança e milhares de senhas foram expostas]]></description>
                                            <content:encoded><![CDATA[<p>Após o <a href="https://www.noticiasaominuto.com.br/tech/586278/twitter-pede-aos-330-milhoes-de-usuarios-que-mudem-senhas" target="_blank">vazamento monumental</a>, que expôs senhas em formato de lista, de milhões de usuários, o Twitter garante que não há indícios, no entanto, de que contas tenham sido invadidas devido à exposição. Enquanto não há maiores detalhes sobre o que ocorreu, o mais seguro é mudar a senha - inclusive em outras redes sociais, caso ela seja a mesma do microblog. Imediatamente.</p>

<p>Uma das maneiras de mudar a senha é acessar <a href="http://twitter.com" target="_blank"><span class="news_italic">Twitter.com,</span></a> inserir dados de login e clicar na imagem de perfil da própria conta, no canto superior direito, e selecionar a opção "Definições e Privacidade". Em seguida, clique em "Senha", listada do lado esquerdo.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/586990/iphone-7-e-7-plus-alguns-aparelhos-estao-com-falha-no-microfone">+ iPhone 7 e 7 Plus: alguns aparelhos estão com falha no microfone</a></p>
<p>Como em qualquer operação padrão de mudança de senha, o Twitter pedirá a senha atual e pedirá para que seja trocada. O ideal é que a palavra não seja usada para a mesma finalidade em outras redes sociais. Para apps, também é preciso clicar na foto de perfil, no lado esquerdo, e escolher "Definições e Privacidade". Depois, selecione "Conta" e, por fim, "Mudar a Senha".</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 12:12:55 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aedcb808ecab.jpg?1525533624" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[iPhone 7 e 7 Plus: alguns aparelhos estão com falha no microfone]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586990/iphone-7-e-7-plus-alguns-aparelhos-estao-com-falha-no-microfone?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586990/iphone-7-e-7-plus-alguns-aparelhos-estao-com-falha-no-microfone?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A Apple teria falado sobre o problema em documento interno, vazado pelo MacRumors]]></description>
                                            <content:encoded><![CDATA[<p>Alguns iPhone 7 e 7 Plus, que rodam sistema operacional iOS 11.3 ou superior, têm um bug. A falha - que ainda não se sabe se é de hardware ou software - desabilita o microfone durante telefonemas ou FaceTime. Conforme o MacRumors, a fabricante comandada por Tim Cook está ciente do problema, a julgar por um documento com carimbo da Rede de Serviços Autorizados da Apple.</p>

<p><a href="https://www.noticiasaominuto.com.br/tech/586937/saiba-como-assistir-ao-lancamento-da-nova-missao-da-nasa-a-marte">+ Saiba como assistir ao lançamento da nova missão da Nasa à Marte</a></p>
<p>O documento interno, vazado para o site que reúne rumores e notícias do universo Apple, detalha que usuários de iPhones afetados podem ver que o botão do auto-falante fica cinza em pleno uso. O problema foi denunciado, nos últimos meses, por usuários do Reddit e do Twitter, como alerta o <a href="https://www.theverge.com/circuitbreaker/2018/5/4/17320928/apple-iphone-7-plus-microphone-disabled-phone-call" target="_blank">TheVerge</a>.</p>
<p>Segundo a denúncia, a Apple recomendou aos técnicos que orientassem os usuários a desabilitarem o Bluetooth, antes das chamadas, bem como aparelhos ou acessórios. A medida resolveria o problema.</p>
<p>Em caso de persistência do problema, a saída seria rodar um diagnóstico de áudio, que determinará se o iPhone precisa de conserto, principalmente em caso de aparecerem mensagens como "acessório não reconhecido". A Apple não se pronunciou oficialmente sobre o problema, mas a MacRumors avisou que o problema está sendo resolvido, mesmo que a cobertura técnica tenho expirado.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 10:43:20 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aedb60537030.jpg?1525528187" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Saiba como assistir ao lançamento da nova missão da Nasa à Marte]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586937/saiba-como-assistir-ao-lancamento-da-nova-missao-da-nasa-a-marte?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586937/saiba-como-assistir-ao-lancamento-da-nova-missao-da-nasa-a-marte?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A InSight será lançada na manhã deste sábado]]></description>
                                            <content:encoded><![CDATA[<p>Hoje é um dia importante para a Nasa. A missão InSight será lançada, neste sábado (5). Nas palavras da própria Agência Espacial Norte-americana, a empreitada espacial é especial porque poderá ajudar os cientistas a entenderem a "formação e evolução inicial de todos os planetas rochosos, incluindo a Terra".</p>

<p>O lançamento está marcado para as 7h05 (11h05 de Brasília), direto da Base Aérea de Vandenberg, na Califórnia. A cobertura do lançamento começa às 6h (10h em Brasília), no canal oficial da Nasa no YouTube.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/586782/vaza-hacker-dicas-para-criar-senhas-fortes">+ Vaza, hacker! Dicas para criar senhas fortes</a></p>
<p>O explorer segue para o Planeta Vermelho equipado com sismógrafo, instrumento que detecta e registra as vibrações, que será inserido na superfície do planeta pela primeira vez.</p>
<p>Duas naves menores seguirão a nave-mãe da InSight. Dois satélites do tamanho de caixas de cereais servirão de apoio a comunicações. Outro objetivo da missão, segundo a agência especial norte-americana, é avaliar o impacto causado pela passagem de meteoritos. A InSight será a primeira a escavar a crosta de Marte profundamente, chegando 15 vezes mais longe do que missões anteriores.</p>
<p><iframe src="https://www.youtube.com/embed/wwMDvPCGeE0" width="560" height="315" frameborder="0"></iframe></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 08:01:48 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aed89527db63.jpg?1525516755" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Vaza, hacker! Dicas para criar senhas fortes]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586782/vaza-hacker-dicas-para-criar-senhas-fortes?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586782/vaza-hacker-dicas-para-criar-senhas-fortes?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Código comprido não é tudo: foque em sequências nada óbvias]]></description>
                                            <content:encoded><![CDATA[<p>De redes sociais a correios eletrônicos, as senhas são a porta de acesso para quase todo nosso material na internet. Mas será que suas senhas são fortes o bastante para evitar ataques hackers? O site 'Gizmodo' separou algumas dicas para você criar códigos mais seguros.</p>

<p>Primeiro, <span class="news_bold">evite sua data de nascimento ou o nome do seu animalzinho de estimação</span>, já que estas informações podem ser encontradas facilmente por meio das redes sociais.</p>
<p>+<a href="https://www.noticiasaominuto.com.br/tech/586641/fazer-compras-pelo-instagram-vai-ficar-ainda-mais-facil" target="_blank"> Fazer compras pelo Instagram vai ficar ainda mais fácil</a></p>
<p><span class="news_highlight" style="background-color: #fff1aa;">Lembre-se que quanto maior a senha, melhor.</span> Mas comprimento não é tudo: é importante criar códigos complicados, que sejam longe de "previsíveis".</p>
<p>"Hackers não vão testar cegamente todas as senhas de oito caracteres e todas as senhas de nove caracteres", afirma o especialista em segurança do gerenciador de senhas <span class="news_italic">1Password</span>, Jeffrey Goldberg. "Eles adivinham as mais óbvias antes. Esses hackers sabem mais sobre como as pessoas criam senhas do que qualquer um", completa.</p>
<p>É importante saber que os hackers têm plena noção de que internautas são induzidos a usar números e letras maiúsculas e minúsculas. Segundo a reportagem, uma senha “MeDeixaEntr4r” não é muito mais forte do que “Medeixeentrar”, por exemplo.</p>
<p>Usar senhas diferentes para cada plataforma é outro método indicado. Especialistas ouvidos pelo GizModo dizem que usar <span class="news_bold">senha em frase</span> pode ser a opção mais forte - e mais fácil de ser lembrada. Para isso, escolha uma coleção aleatória de palavras, salpicadas de maiúsculas e símbolos nada previsíveis.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/586696/ataque-hacker-expoe-dados-de-100-mil-clientes-do-banco-inter" target="_blank">Ataque hacker expõe dados de 100 mil clientes do banco Inter</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 05 May 2018 07:06:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5890e889dbdb4.jpg?1525465417" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Empresa chinesa dá show com 1,3 mil drones e bate recorde mundial; veja]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586862/empresa-chinesa-da-show-com-1-3-mil-drones-e-bate-recorde-mundial-veja?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586862/empresa-chinesa-da-show-com-1-3-mil-drones-e-bate-recorde-mundial-veja?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Espetáculo durou 13 minutos]]></description>
                                            <content:encoded><![CDATA[<p>A empresa chinesa Ehang Egret entrou para o livro dos recordes Guiness ao colocar no ar 1.374 drones de forma simultânea. O espetáculo durou 13 minutos.</p>

<p>De acordo com o G1, o recorde anterior era da Intel, quando 1.218 drones decolaram durante os Jogos Olímpicos de Inverno de 2018, sediado na Coreia do Sul.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/586796/veiculo-autonomo-da-waymo-se-envolve-em-acidente-nos-eua" target="_blank">Veículo autônomo da Waymo se envolve em acidente nos EUA</a></p>
<p>Assista ao espetáculo:</p>
<p><iframe src="https://www.youtube.com/embed/4mHDDG3FCjs" width="560" height="315" frameborder="0"></iframe></p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 04 May 2018 20:19:33 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aecea5777fee.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Fazer compras pelo Instagram vai ficar ainda mais fácil]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586641/fazer-compras-pelo-instagram-vai-ficar-ainda-mais-facil?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586641/fazer-compras-pelo-instagram-vai-ficar-ainda-mais-facil?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Rede social confirma que opção está sendo testada com um grupo limitado de usuários]]></description>
                                            <content:encoded><![CDATA[<p>O Instagram continua investindo nos seus planos de se tornar uma app de compras. A rede social está testando uma funcionalidade que permite ao usuário comprar produtos e serviços e pagar por eles diretamente no aplicativo.</p>

<p>O Instagram confirmou ao TechCrunch que está testando a opção com um grupo limitado de usuários e parceiros, como restaurantes e salões de beleza. Estima-se que, em breve, os usuários do Instagram possam comprar, inclusive, bilhetes de cinema.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/586537/nova-missao-da-nasa-vai-investigar-terremotos-em-marte-entenda" target="_blank">Nova missão da Nasa vai investigar terremotos em Marte; entenda</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 04 May 2018 19:37:11 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a30dc22e5202.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Veículo autônomo da Waymo se envolve em acidente nos EUA]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586796/veiculo-autonomo-da-waymo-se-envolve-em-acidente-nos-eua?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586796/veiculo-autonomo-da-waymo-se-envolve-em-acidente-nos-eua?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Infração ocorreu na cidade de Chandler, no Arizona]]></description>
                                            <content:encoded><![CDATA[<p>Mais um veículo autônomo se envolveu em acidentes nos Estados Unidos. Desta vez, um carro da Waymo sofreu uma colisão na tarde desta sexta-feira (4) na cidade de Chandler, no Arizona (EUA).</p>

<p>De acordo com o 'The Verge', autoridades locais informaram que o carro estava em modo autônomo e tinha uma pessoa ao volante no momento do acidente. Segundo a reportagem, a Polícia garantiu que o veículo da Waymo não foi o "infrator".</p>
<p>A Waymo ainda não se manifestou sobre o ocorrido. Até o momento, não há informações sobre feridos.</p>
<blockquote class="twitter-tweet" data-lang="pt">
<p dir="ltr" lang="en">Right now: Pretty gnarly crash with an <a href="https://twitter.com/Waymo?ref_src=twsrc%5Etfw">@Waymo</a> van in Chandler, AZ. No visible injuries. <a href="https://t.co/xBLYfDsQP7">pic.twitter.com/xBLYfDsQP7</a></p>
— Matt Jaffee (@mattjaffee) <a href="https://twitter.com/mattjaffee/status/992489072957440001?ref_src=twsrc%5Etfw">4 de maio de 2018</a></blockquote>
<p>
<script charset="utf-8" src="https://platform.twitter.com/widgets.js" async=""></script>
</p>
<p>Leia também :<a href="https://www.noticiasaominuto.com.br/tech/586782/vaza-hacker-dicas-para-criar-senhas-fortes" target="_blank">Vaza, hacker! Dicas para criar senhas fortes</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 04 May 2018 18:08:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5894dc14ebef5.jpg?1525468134" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Ataque hacker expõe dados de 100 mil clientes do banco Inter]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586696/ataque-hacker-expoe-dados-de-100-mil-clientes-do-banco-inter?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586696/ataque-hacker-expoe-dados-de-100-mil-clientes-do-banco-inter?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Instituição bancária nega]]></description>
                                            <content:encoded><![CDATA[<p>Dados pessoais de cerca de 100 mil clientes do Banco Inter foram expostos, durante as últimas semanas, após um suposto ataque hacker. Senhas, fotos de cheques e documentos estão entre os arquivos presentes em uma pasta criptografada de 40 GB, que foi recebida pelo site 'TecMundo'.</p>

<p>De acordo com a reportagem, um hacker autodenominado "John" enviou um manifesto ao portal dizendo como teve acesso a estes dados, e quais foram os motivos que o levaram a invadir o sistema do banco. Ele também dá detalhes de uma suposta situação de extorsão, afirmando que o banco pagaria para deixar "este caso de lado". O hacker disse que o pagamento não foi realizado.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/586641/fazer-compras-pelo-instagram-vai-ficar-ainda-mais-facil" target="_blank">Fazer compras pelo Instagram vai ficar ainda mais fácil</a></p>
<p>"John" disse que explorou uma brecha na nuvem do sistema bancário para obter os dados dos clientes do banco.</p>
<p>Em comunicado, o Banco Inter nega a notícia. Confira a nota na íntegra:</p>
<p><span class="news_italic">"O Banco Inter comunica que foi vítima de tentativa de extorsão e que imediatamente constatou que não houve comprometimento da segurança no ambiente externo e nem dano à sua estrutura tecnológica. A companhia esclarece, ainda, que comunicou o fato às autoridades competentes e a investigação corre em sigilo.</span></p>
<p><span class="news_italic">Reforça também que, conforme a Lei 5.250/1967, Art. 16, é crime a divulgação de "notícias falsas ou fatos verdadeiros truncados ou deturpados" a respeito de instituição financeira, ou para causar “perturbação da ordem pública ou alarma social".</span></p>
<p><span class="news_italic">O TecMundo confirmou 81,609 mil nomes no vazamento, enquanto o hacker afirma serem mais de 300 mil nomes envolvidos, o que incluiria todos os clientes do banco — muitos documentos dentro do arquivo de 40 GB estavam protegidos por senhas, não sendo possível a confirmação das outras milhares de contas alegadas.</span></p>
<p><span class="news_italic">O Banco Inter, que também recebeu o arquivo de 40 GB, negou uma invasão e comentou: "O Banco Inter segue as regulamentações de segurança aplicáveis à natureza do serviço prestado, estando em conformidade com as boas práticas no que se refere à proteção dos dados pessoais de seus clientes. Nesse sentido, busca constantemente o aperfeiçoamento de sua segurança digital. Inclusive, é pioneiro na migração de dados para computação em nuvem junto ao seu parceiro Amazon Web Services"</span></p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 04 May 2018 14:55:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_57603734521d8.jpg?1525456535" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Saiba qual é o smartphone mais vendido de 2018]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586605/saiba-qual-e-o-smartphone-mais-vendido-de-2018?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586605/saiba-qual-e-o-smartphone-mais-vendido-de-2018?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Ranking foi divulgado pelo Strategy Analytics]]></description>
                                            <content:encoded><![CDATA[<p>De acordo com a empresa de análise de mercado Strategy Analytics, o smartphone mais vendido do primeiro trimestre de 2018 foi o iPhone X, alcançando a marca de 16 milhões de unidades vendidas.</p>

<p>Na sequência do ranking aparece o iPhone 8 e o iPhone 8 Plus, que venderam 12.5 milhões e 8.3 milhões de unidades, respectivamente.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/586278/twitter-pede-aos-330-milhoes-de-usuarios-que-mudem-senhas" target="_blank">+ Twitter pede aos 330 milhões de usuários que mudem senhas</a></p>
<p>Os números contrariam as previsões dos analistas, que apontavam para um fracasso do mais recente smartphone da Apple por conta do preço elevado.</p>
<p>Como recorda o CNet, as vendas correspondem com o estimado pelo CEO da Apple, Tim Cook. Ele havia dito anteriormente que o iPhone X seria o dispositivo mais vendido da empresa durante todas as semanas do trimestre.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 04 May 2018 12:23:43 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a3bf3975a12e.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Nova missão da Nasa vai investigar terremotos em Marte; entenda]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586537/nova-missao-da-nasa-vai-investigar-terremotos-em-marte-entenda?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586537/nova-missao-da-nasa-vai-investigar-terremotos-em-marte-entenda?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Um dos objetivos da missão InSight é avaliar o impacto causado pela passagem de meteoritos]]></description>
                                            <content:encoded><![CDATA[<p>Em <a href="https://www.noticiasaominuto.com.br/tech/586153/nasa-lancara-no-proximo-sabado-nave-que-escavara-o-solo-de-marte" target="_blank">nova missão a Marte, a Nasa pretende investigar o interior do Planeta Vermelho</a> e passar a medir a frequência e intensidade de terremotos que acontecem por lá. Um sismógrafo, instrumento que detecta e registra as vibrações, será inserido na superfície do planeta pela primeira vez.</p>

<p>Outro objetivo da missão, segundo a agência especial norte-americana, é avaliar o impacto causado pela passagem de meteoritos.</p>
<p> </p>
<p>Denominada de InSight, a missão será a primeira a escavar a crosta de Marte profundamente, chegando 15 vezes mais longe do que missões anteriores.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/586464/teste-da-nasa-podera-permitir-viagens-espaciais-mais-longas" target="_blank">+ Teste da NASA poderá permitir viagens espaciais mais longas</a></p>
<p>Com a missão, a Nasa espera entender a formação e evolução de planetas rochosos, como Marte e a Terra.</p>
<p>"A InSight é uma missão até Marte, mas é mais do que só uma missão até Marte. Ela ajudará os cientistas a entenderem a formação e evolução inicial de todos os planetas rochosos, incluindo a Terra", explica a agência espacial.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 04 May 2018 10:11:47 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aec5bfab34f3.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Teste da NASA poderá permitir viagens espaciais mais longas]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586464/teste-da-nasa-podera-permitir-viagens-espaciais-mais-longas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586464/teste-da-nasa-podera-permitir-viagens-espaciais-mais-longas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Agência espacial norte-americana testou com sucesso um reator nuclear que providenciará energia no E]]></description>
                                            <content:encoded><![CDATA[<p>A NASA testou com sucesso um reator nuclear que virá a fornecer energia no Espaço, abrindo a possibilidade de missões mais prolongadas. Chamado de Kilopower, o projeto foi realizado em parceria com o Departamento de Energia dos EUA.</p>

<p>“Segurança, eficiência e bastante energia serão a chave na exploração robótica e humana do futuro. Espero que o projeto Kilopower venha a ser uma parte essencial das arquiteturas de energia da Lua e de Marte à medida que evoluam”, consta no comunicado da NASA compartilhado pelo Cnet.</p>
<p>O teste ao reator nuclear do projeto Kilopower aconteceu em Nevada, nos Estados Unidos. O objetivo era demonstrar que o sistema tem capacidade para criar energia de forma estável e segura.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/586153/nasa-lancara-no-proximo-sabado-nave-que-escavara-o-solo-de-marte" target="_blank">Nasa lançará no próximo sábado nave que escavará o solo de Marte</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 04 May 2018 07:48:11 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_565ebe0a1e255.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Zuckerberg ri e não responde se Facebook é uma empresa de mídia]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586250/zuckerberg-ri-e-nao-responde-se-facebook-e-uma-empresa-de-midia?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586250/zuckerberg-ri-e-nao-responde-se-facebook-e-uma-empresa-de-midia?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Ele foi questionado por uma jornalista a respeito do tema]]></description>
                                            <content:encoded><![CDATA[<p>O presidente do Facebook, Mark Zuckerberg, se esquivou da pergunta sobre a rede social ser uma ou não empresa de mídia, segundo a editora da revista The Atlantic Adrienne LaFrance.</p>

<p>Ele foi questionado pela jornalista a respeito do tema ao final de encontro reservado com jornalistas, e executivos em Palo Alto (EUA).</p>
<p>Zuckerberg riu e não disse nada. Avisado de que era uma pergunta séria, riu novamente, escreveu a jornalista em texto publicado na terça-feira (1º).</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/586278/twitter-pede-que-usuarios-troquem-senha-devido-a-falha" target="_blank">Twitter pede que usuários troquem senha devido a falha</a></p>
<p>Na reunião, o presidente do Facebook disse que a empresa possui duas responsabilidades em relação a notícias: garantir que os usuários da rede recebam informações confiáveis e ajudá-los a construir um repertório comum de conhecimentos e fatos que permitam debates entre eles.</p>
<p>A jornalista aponta contradições no fato de Zuckerberg defender a importância do jornalismo e querer fomentar discussões a partir desse terreno comum de conhecimentos ao mesmo tempo que dá pouca importância ao conteúdo jornalístico na rede social.</p>
<p>LaFrance aponta que o Facebook, junto com o Google, drenaram a maior parte da receita publicitária online das empresas de mídia.</p>
<p>Também critica o fato de a rede não pagar produtores que usam suas plataformas para divulgar seus conteúdos e por ter decidido, em janeiro deste ano, priorizar mais postagens feitas por amigos do que as publicações de empresas de jornalismo profissional no que é mostrado na linha do tempo de usuários.</p>
<p>"Penso que notícias são incrivelmente importantes para a sociedade e para a democracia. Porém notícias são uma pequena minoria do conteúdo lido no Facebook", disse Zuckerberg, segundo o relato.</p>
<p>Citando trechos da conversa, LaFrance também aponta que Zuckerberg vê pouca diferença entre opinião de amigos e conteúdo jornalístico profissional.  "Penso que, em geral, as empresas jornalísticas têm uma opinião. Muito do que vocês fazem é ter uma opinião", disse ele. "O Facebook tem mais opiniões. Mostrando aos usuários mais opiniões, eles têm mais opções."</p>
<p>Zuckerberg defendeu um modelo de apoio financeiro ao jornalismo oriundo do governo, citando o caso da rede pública britânica de televisão BBC.</p>
<p>Questionado sobre a possibilidade de o próprio Facebook poder patrocinar o jornalismo, beneficiando empresas que usam sua plataforma, ele disse não ter certeza se isso faria sentido.</p>
<p>O secretários de Redação do The New York Times, Joseph Kahn, também presente à reunião, criticou a fala de Zuckerberg, chamando ela de totalmente "Trumpiana", segundo LaFrance.</p>
<p>Kahn, de acordo com o relato da jornalista, disse que a compreensão de Zuckerberg sobre o que é jornalismo é particularmente prejudicial em tempos em que o presidente americano faz ataques à imprensa livre. Com informações da Folhapress. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Folhapress</dc:creator>
                    <pubDate>Fri, 04 May 2018 06:03:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_56050fc57ffc8.jpg?1525383766" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Twitter pede aos 330 milhões de usuários que mudem senhas]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586278/twitter-pede-aos-330-milhoes-de-usuarios-que-mudem-senhas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586278/twitter-pede-aos-330-milhoes-de-usuarios-que-mudem-senhas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Erro foi corrigido, mas rede social adotou medida de precaução]]></description>
                                            <content:encoded><![CDATA[<p> </p>

<p>O Twitter pediu nesta quinta (3) a seus mais de 330 milhões de usuários que mudem suas senhas, depois que uma falha fez com que algumas delas fossem armazenadas em texto em seu sistema interno de computadores.</p>
<p>A rede social disse que consertou a falha e que uma investigação interna não encontrou senhas que foram roubadas ou usadas por pessoas de dentro, mas pediu a todos os usuários que considerem a mudança de suas senhas por cautela.</p>
<p>O Twitter sugere precauções como a ativação do serviço de autenticação em dois fatores, para ajudar a impedir que contas sejam sequestradas.</p>
<p>O blog do Twitter não informou quantas senhas foram afetadas. Mas uma pessoa familiarizada com o assunto disse que o número era substancial e que elas foram expostas por vários meses.De acordo com a pessoa, a empresa descobriu a falha há algumas semanas e informou reguladores.</p>
<p>"Lamentamos muito que isso tenha acontecido", afirmou o Twitter em seu blog.</p>
<p>A falha está relacionada ao uso por parte da empresa de uma tecnologia conhecida como "hashing", que mascara as senhas quando um usuário as digita, substituindo-as por números e letras, de acordo com o blog. Um bug fez com que as senhas fossem escritas em um registro interno do computador antes que o processo de hashing fosse concluído.</p>
<p>Recomendações de segurança</p>
<p>Se você usa a mesma senha do Twitter em outros sites ou redes sociais, deve trocá-la</p>
<p>Use uma senha que você não usa em outros locais.</p>
<p>Ative a verificação do login, também chamada de de autenticação de dois fatores</p>
<p>Use um gerenciador de senha para garantir senhas fortes (não óbvias e que misturam letras, números e caracteres especiais). Com informações da Folhapress.</p>
<p> </p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585293/whatsapp-vai-ganhar-videoconferencia-em-grupo-e-stickers" target="_blank">WhatsApp vai ganhar videoconferência em grupo e 'stickers'</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Folhapress</dc:creator>
                    <pubDate>Fri, 04 May 2018 05:06:37 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5994b41a66af3.jpg?1525382042" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Nasa lançará no próximo sábado nave que escavará o solo de Marte]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586153/nasa-lancara-no-proximo-sabado-nave-que-escavara-o-solo-de-marte?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586153/nasa-lancara-no-proximo-sabado-nave-que-escavara-o-solo-de-marte?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Até agora, nenhuma missão analisou a evolução inicial do planeta, que só pode ser estudada observand]]></description>
                                            <content:encoded><![CDATA[<p>A missão InSight, da Nasa, enviará a Marte a primeira sonda capaz de perfurar o solo e estudar o interior do Planeta Vermelho. O lançamento da sonda está programado para ocorrer neste sábado, 5, às 6h05 da manhã. Segundo a Nasa, há uma probabilidade de 20% de que as condições meteorológicas permitam o lançamento.</p>

<p>A missão Exploração Interior com uso de Investigação Sísmica, Geodésia e Transporte de Calor (InSitght, sigla em inglês) colocará um módulo de pouso geofísico em Marte para estudar o interior do planeta. Mas, segundo a Nasa, seu objetivo vai além disso: a sonda também estudará questões fundamentais da ciência dos planetas e do Sistema Solar, para que os pesquisadores compreendam os processos que levaram à formação dos planetas rochosos do Sistema Solar Interno - entre eles a Terra - há mais de 4 bilhões de anos.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/585864/cientistas-criam-embriao-de-rato-a-partir-de-celulas-tronco" target="_blank">Cientistas criam embrião de rato a partir de células-tronco</a></p>
<p>Segundo a Nasa, missões anteriores enviadas a Marte investigaram a história da superfície do planeta a partir da análise de características de seus cânions, vulcões, rochas, montanhas e solo. Mas, até agora, nenhuma missão analisou a evolução inicial do planeta, que só pode ser estudada observando o subsolo.</p>
<p>Utilizando instrumentos geofísicos sofisticados, o módulo escavará pela primeira vez a superfície marciana para detectar pela primeira vez as marcas dos processos de formação dos planetas rochosos e para medir os "sinais vitais" de Marte: seu "pulso" (sismologia), "temperatura" (fluxos de calor) e "reflexos" (rastreamento de precisão).</p>
<p>Para estudar o solo marciano, a InSight é equipada com diversos instrumentos operados por um braço robótico, incluindo sismômetros - que medem as ondas sísmicas provocadas por impactos de meteoros e por "martemotos" - e uma broca com uma sonda térmica, que irá perfurar o solo em até 5 metros e medir os fluxos de calor no interior do planeta.</p>
<p>Como Marte é geologicamente menos ativo que a Terra - ele não possui placas tectônicas, por exemplo -, o planeta mantém um registro mais completo de sua história em sua crosta, seu manto e seu núcleo. Ao estudar essas características, os cientistas poderão descobrir mistérios sobre os processos evolutivos de todos os planetas rochosos.</p>
<p>Antes da InSight, 14 missões já haviam sido enviadas a Marte. Nove delas foram lançadas pelos Estados Unidos, sendo que duas fracassaram, em 1999. Das demais missões - todas fracassadas - três foram lançadas pela União Soviética, uma pelo Reino Unido e uma por uma parceria entre as agências espaciais da Europa e da Rússia.</p>
<p><strong>Costa Oeste</strong></p>
<p>Pela primeira vez uma missão planetária será lançada a partir da costa oeste dos Estados Unidos. Em vez da tradicional base de lançamento do Centro Espacial Kennedy, na Flórida, a InSight será enviada a partir da Base Vandenberg da Força Aérea Americana, localizada na região de Santa Bárbara, na Califórnia.</p>
<p>No lançamento, será utilizado o foguete Atlas V, da United Launch Alliance, uma joint venture das empresas Lockheed Martin e Boeing. Além da InSight, o foguete levará ao espaço também o experimento tecnológico Mars Cube One (MarCO).</p>
<p>Composto por duas miniespaçonaves, o MarCO testará pela primeira vez no espaço profundo uma tecnologia de CubeSat, termo que remete às palavras "cubo" e "satélite" em inglês. Esse tipo de satélite miniaturizado - ou nanossatélite - é em geral utilizado para pesquisas espaciais acadêmicas. Os dois pequenos equipamentos foram desenvolvidos para testar novas tecnologias de comunicação e navegação para missões espaciais.</p>
<p>A missão InSight é parte do Programa Descoberta, da Nasa. A nave - incluindo o estágio de cruzeiro e o módulo de pouso - foi construída e testada pela Lockeed Martin Space, em Denver, Nos Estados Unidos. O programa tem participação de várias instituições europeias, como a Agência Espacial Francesa, o Centro Nacional de Estudos Espaciais da França e o Centro Aeroespacial da Alemanha. Com informações do Estadão Conteúdo. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Estadao Conteudo</dc:creator>
                    <pubDate>Thu, 03 May 2018 16:34:05 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aeb65a5607ab.jpg?1525376457" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Tesla confirma novo carro para 2020]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586195/tesla-confirma-novo-carro-para-2020?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586195/tesla-confirma-novo-carro-para-2020?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Mesmo que já esteja pensando no Model Y, Musk ainda tem de normalizar a produção do Model 3]]></description>
                                            <content:encoded><![CDATA[<p>A Tesla confirmou no seu último relatório financeiro trimestral que o próximo veículo, o Model Y, começará a ser produzido em 2020. Porém, não foram ainda divulgados nenhum detalhe a respeito do novo modelo. </p>

<p>Como conta o Gizmodo, o próprio CEO da Tesla, Elon Musk, não sabe onde produzirá o seu ‘crossover’ elétrico. “Estamos cheios aqui [na fábrica] de Fremont. Não sei onde colocarei o Model Y”, admitiu.</p>
<p>Mesmo que já esteja pensando no Model Y, Musk ainda tem de normalizar a produção do Model 3, modelo cujos números de produção têm estado abaixo das metas estabelecidas pela empresa. Numa medida ‘desesperada’, o próprio Musk decidiu se envolver na produção e procurar torná-la o mais eficaz possível.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585895/garoto-de-11-anos-ja-desenvolveu-sete-apps-para-iphone" target="_blank">Garoto de 11 anos já desenvolveu sete apps para iPhone</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Thu, 03 May 2018 15:51:55 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5acf1fc78eb77.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Ford criou uma forma de cegos 'sentirem' a paisagem em viagens]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586170/ford-criou-uma-forma-de-cegos-sentirem-a-paisagem-em-viagens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586170/ford-criou-uma-forma-de-cegos-sentirem-a-paisagem-em-viagens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[O dispositivo ‘Feel the View’ é capaz de captar uma imagem e traduzi-la em braille para o vidro carr]]></description>
                                            <content:encoded><![CDATA[<p>A Ford criou um pequeno dispositivo que, quando aplicado à janela de um carro, permite a cegos ‘sentirem’ a paisagem que está a volta. O aparelho recebeu o nome ‘Feel the View’ (Sinta a vista, em português) e é capaz de captar uma fotografia da paisagem e traduzi-la em braile por via de 27 pontos no vidro do carro.</p>

<p>O ‘Feel the View’ foi desenvolvido pela equipe italiana da Ford em colaboração com a Aedo, uma startup que se foca em dispositivos voltados para cegos. Além dos pontos e vibrações no vidro, o ‘Feel the View’ também faz uso de um assistente digital que, por via oral, ajuda a colocar a imagem no contexto da viagem, conta o <a href="https://www.designboom.com/technology/ford-window-feel-view-05-02-2018/" target="_blank">DesignBoom</a>.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/585864/cientistas-criam-embriao-de-rato-a-partir-de-celulas-tronco" target="_blank">Cientistas criam embrião de rato a partir de células-tronco</a></p>
<p>Ficou curioso? O vídeo abaixo dá uma ideia de como o ‘Feel the View’ funciona e das suas potencialidades para o futuro.</p>
<p><iframe src="https://www.youtube.com/embed/CDfqPMmNmmk" width="560" height="315" frameborder="0"></iframe></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Thu, 03 May 2018 15:08:50 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aeb505a0d768.jpg?1525371005" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Apple promete novidades na bateria do próximo iPhone X]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586070/apple-promete-novidades-na-bateria-do-proximo-iphone-x?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586070/apple-promete-novidades-na-bateria-do-proximo-iphone-x?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Dispositivo conhecido como iPhone X2 terá carregadores preparados para recarga rápida]]></description>
                                            <content:encoded><![CDATA[<p>O sucessor do iPhone X – que está sendo chamado de iPhone X2 – incluirá na caixa um carregador preparado para recarga rápida, algo que até agora só é possível caso acessórios específicos sejam adquiridos separadamente.</p>

<p>Segundo o rumor divulgado pelo site Chongdiantou (via TechRadar), apesar da informação ainda não estar confirmada, colocaria a Apple no mesmo patamar que rivais como a Samsung e a Huawei no que diz respeito à tecnologia de recarga rápida.</p>
<p>É possível que a confirmação para a inclusão deste tipo de carregadores na caixa do iPhone X2 aconteça apenas na revelação oficial do dispositivo que, tradicionalmente, acontece em setembro.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/586068/spotify-chega-a-75-milhoes-de-assinantes-e-170-milhoes-de-usuarios" target="_blank">Spotify chega a 75 milhões de assinantes e 170 milhões de usuários</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Thu, 03 May 2018 12:25:02 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_59b906803345b.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Spotify chega a 75 milhões de assinantes e 170 milhões de usuários]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/586068/spotify-chega-a-75-milhoes-de-assinantes-e-170-milhoes-de-usuarios?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/586068/spotify-chega-a-75-milhoes-de-assinantes-e-170-milhoes-de-usuarios?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Só nos três primeiros meses de 2018, serviço de streaming ganhou 4 milhões de novos assinantes]]></description>
                                            <content:encoded><![CDATA[<p>O Spotify atingiu a marca de 75 milhões de usuários pagantes. Em plena ascensão, este é o primeiro balanço anunciado pelo serviço de streaming desde que se tornou uma empresa de capital aberto.</p>

<p>Nos três primeiros meses de 2018, a empresa ganhou 4 milhões de novos assinantes. O número é grandioso, mas não surpreendeu, pois já era previsto pela companhia.</p>
<p>No total, são 170 milhões de usuários que usam a plataforma ao menos uma vez por mês, contando também com o público que utiliza a versão grátis, suportada por publicidade.</p>
<p>Uma comparação com o concorrente Apple Music pode ajudar a entender os números divulgados pelo Spotify. O serviço da Apple atingiu recentemente a marca de 38 milhões de assinantes pagantes, além de não possuir modalidade grátis.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/585293/whatsapp-vai-ganhar-videoconferencia-em-grupo-e-stickers" target="_blank">+ WhatsApp vai ganhar videoconferência em grupo e 'stickers'</a></p>
<p>Por outro lado, mesmo sendo líder absoluto do mercado, o Spotify ainda registra prejuízo financeiro. A empresa reportou um prejuízo na casa dos 169 milhões de euros. Em 2017, o rombo era de 173 milhões de euros. Já o faturamento subiu e atingiu 1,14 bilhão de euros, um aumento de 26%.</p>
<p>Os números não agradaram os investidores, fazendo com que as ações da empresa despencassem 9% após o anúncio.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Thu, 03 May 2018 12:05:09 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a4cdb36094df.jpg?1525360274" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[WhatsApp vai ganhar videoconferência em grupo e 'stickers']]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585293/whatsapp-vai-ganhar-videoconferencia-em-grupo-e-stickers?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585293/whatsapp-vai-ganhar-videoconferencia-em-grupo-e-stickers?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Novidade é anunciada na conferência F8, do Facebook]]></description>
                                            <content:encoded><![CDATA[<p>Foi confirmado durante a conferência F8 do Facebook que o WhatsApp receberá ao longo dos próximos meses a capacidade de realizar videoconferências, permitindo que até quatro pessoas participem da mesma conversa.</p>

<p>Esta tem sido uma das funcionalidades mais pedidas pelos cerca 450 milhões de usuários do app. Além disso, também serão inseridos os chamados stickers, que colocarão o WhatsApp um pouco mais perto de rivais como o Facebook Messenger, a Line e o WeChat.</p>
<p>Os stickers não serão limitados aos lançados pelo WhatsApp. Outros desenvolvedores também poderão criar os seus próprios conjuntos de figurinhas.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585339/apple-respira-aliviada-vendas-de-iphone-voltam-a-subir" target="_blank">Apple respira aliviada: vendas de iPhone voltam a subir</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Thu, 03 May 2018 10:47:01 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae975040fa15.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Instagram: stories serão integradas a Spotify e GoPro]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585752/instagram-stories-serao-integradas-a-spotify-e-gopro?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585752/instagram-stories-serao-integradas-a-spotify-e-gopro?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A rede social promete a integração de mais aplicativos daqui para a frente]]></description>
                                            <content:encoded><![CDATA[<p>As Stories do Instagram estão prestes a ficar mais diversificadas com a integração de apps como o Spotify ou o da GoPro. O objetivo é permitir uma partilha de conteúdos de forma mais fluída e intuitiva.</p>

<p>No aplicativo do Instagram ou da GoPro vai ter uma opção de partilhar músicas e fotografias/vídeo diretamente nos Stories, sendo que no caso da GoPro terão ferramentas criadas para permitir a realização de uma edição rápida dos conteúdos que o usuário decida publicar.</p>
<p>O Instagram anunciou ainda que será possível integrar nos Stories efeitos de Realidade Aumentada por via da Camera Effects Platform do Facebook.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585513/65-bilhoes-de-mensagens-sao-enviadas-pelo-whatsapp-diariamente" target="_blank">65 bilhões de mensagens são enviadas pelo WhatsApp diariamente</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Thu, 03 May 2018 06:36:11 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5827a5df5d718.jpg?1525302946" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Cientistas criam embrião de rato a partir de células-tronco]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585864/cientistas-criam-embriao-de-rato-a-partir-de-celulas-tronco?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585864/cientistas-criam-embriao-de-rato-a-partir-de-celulas-tronco?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[O desenvolvimento atingiu a fase de 'blastocisto']]></description>
                                            <content:encoded><![CDATA[<p>Cientistas da Universidade de Maastricht, na Holanda, desenvolveram um embrião de rato "artificial", ou seja, a partir de células-tronco, e não de células reprodutivas. No entanto, ele não se demonstrou capaz de chegar à fase madura.</p>

<p>O estudo foi publicado na revista "Nature" e abre caminho para novas pesquisas sobre as etapas iniciais do desenvolvimento de seres vivos.</p>
<p>No trabalho, coordenado por Nicolas Rivron, os cientistas usaram células-tronco que dão origem à placenta e ao organismo. Na proveta, elas formaram uma estrutura similar a um embrião em estágio inicial, o blastocisto.</p>
<p>O embrião "artificial" foi chamado de "blastoide", uma esfera feita de camadas sutis. A hipótese dos pesquisadores é que o estudo abra caminho para, em um futuro ainda distante, se desenvolver seres vivos "artificiais".</p>
<p>Além disso, a pesquisa possibilita um laboratório sem precedentes para se estudar as fases iniciais do desenvolvimento embrionário, como a formação da placenta. "Entender isso é importante pois permite compreender os mecanismos da infertilidade, que nasce de defeitos na implantação do embrião", declarou o geneticista italiano Giuseppe Novelli, reitor da Universidade de Roma Tor Vergata.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/585647/ultimo-artigo-de-hawking-tenta-definir-origem-do-universo" target="_blank">+ Último artigo de Hawking tenta definir origem do Universo</a></p>
<p>Segundo ele, a grande descoberta da pesquisa holandesa é o desenvolvimento da estrutura embrionária que gera a placenta, chamada "trofoblasto". "O objetivo é entender como se forma o trofoblasto, como ele dialoga com o útero e quais genes se ativam", disse.</p>
<p>Uma placenta obtida com células-tronco, explica Novelli, nunca levará a um embrião avançado, algo que exige informações genéticas das células reprodutivas dos dois sexos. Com informações da Ansa.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Ansa</dc:creator>
                    <pubDate>Thu, 03 May 2018 06:19:07 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aead52da93d7.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Pivô de polêmica sobre privacidade no Facebook fecha]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585591/pivo-de-polemica-sobre-privacidade-no-facebook-fecha?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585591/pivo-de-polemica-sobre-privacidade-no-facebook-fecha?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Nigel Oakes, fundador do SCL Group, afirmou que tanto a SCL quanto a Cambridge Analytica vão encerra]]></description>
                                            <content:encoded><![CDATA[<p> </p>

<p> Pivô da recente polêmica envolvendo o Facebook e a privacidade dos usuários, a consultoria Cambridge Analytica anunciou que vai encerrar atividades devido a uma queda nos negócios.</p>
<p>A empresa não resistiu à perda de clientes e a multas após investigações sobre o vazamento de dados de 87 milhões de usuários da rede social e sobre o emprego deles para direcionar anúncios de políticos e influenciar eleições.</p>
<p>Entre as votações suspeitas de terem sido alvo de interferência estão o pleito presidencial nos Estados Unidos, em 2016, que elegeu Donald Trump, e o referendo que, no mesmo ano, decidiu pela saída do Reino Unido da União Europeia -o chamado "brexit".</p>
<p> </p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/585513/65-bilhoes-de-mensagens-sao-enviadas-pelo-whatsapp-diariamente" target="_blank">65 bilhões de mensagens são enviadas pelo WhatsApp diariamente</a></p>
<p>O encerramento foi antecipado pelo jornal americano Wall Street Journal nesta quarta (2). A reportagem detalhava que a firma de fato fechou as portas, tendo comunicado funcionários para que desligassem computadores.</p>
<p>As informações foram confirmadas em um comunicado. Segundo o texto, a companhia e sua controladora, a SCL Elections Ltd., iniciaram um pedido de falência.</p>
<p>"O cerco da imprensa afastou quase todos os clientes e fornecedores da companhia", afirma o comunicado.</p>
<p>"Como resultado", prossegue o texto, "a empresa não mais possui condições de operar, e não restam opções que não colocá-la sob administração [externa, em falência]".</p>
<p>A Cambridge Analytica passou a ser investigada na Europa e nos EUA após a divulgação de que dados de perfis de usuários do Facebook haviam sido captados sem autorização e utilizados para influenciar campanhas eleitorais.</p>
<p>A captura se deu com um "quiz" sobre gostos pessoais que, uma vez autorizado pelo participante, coletava dados dele e de amigos sem anuência destes. Comandado pelo pesquisador Aleksandr Kogan, da Universidade de Cambridge, o expediente repassou à consultoria dados de mais de 87 milhões de pessoas.</p>
<p>As informações foram usadas pela consultoria para impulsionar campanhas.</p>
<p>Segundo as investigações, a Cambridge Analytica usava os dados para que anúncios tivessem melhor direcionamento, atingindo potenciais eleitores com informações e argumentos aos quais eram mais sensíveis.</p>
<p>Após o anúncio, a agência britânica que regula dados e privacidade informou que vai prosseguir com investigações nas áreas civil e criminal e que vai responsabilizar "indivíduos e diretores", a despeito do fechamento.</p>
<p>A empresa nega as acusações e diz que "apesar dos muitos esforços, foi vista como vilã por atividades que são não só legais, mas aceitas como padrão sobre anúncios digitais tanto na arena política quanto na comercial".</p>
<p>Usuários, entidades e governos, contudo, discordam da correição das atividades da consultoria. Suas críticas nos últimos meses causaram uma crise sem precedentes, que arrastou também o Facebook.</p>
<p>O escândalo do vazamento de dados obrigou o fundador da rede social, Mark Zuckerberg, a dar um longo depoimento ao Congresso dos Estados Unidos, em abril.</p>
<p>A plataforma gora tenta evitar processos judiciais e multas de até US$ 40 mil (R$ 131 mil) por usuário afetado.</p>
<p>O Facebook também adotou medidas para responder à crise, como a divulgação de seu manual de conduta e a elevação da idade mínima para o uso do WhatsApp na Europa.</p>
<p>Mas as explicações não foram consideradas convincentes por usuários, analistas e políticos, e a empresa sofre com críticas e baixas.</p>
<p>Uma delas foi a do fundador do WhatsApp, Jan Koum, que vendeu o aplicativo ao Facebook em 2014 por R$ 66 bilhões e, neste ano, decidiu se afastar da companhia alegando preocupação com a segurança dos dados.</p>
<p>Apesar da crise, o Facebook teve alta de quase 50% em seu faturamento no primeiro trimestre de 2018, que atingiu US$ 11,97 bilhões (cerca de R$ 41,66 bilhões). Com informações da Folhapress. </p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Folhapress</dc:creator>
                    <pubDate>Wed, 02 May 2018 22:16:56 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ada10100ed72.jpg?1525289481" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Instagram testa capacidade de 'silenciar' perfis]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585777/instagram-testa-capacidade-de-silenciar-perfis?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585777/instagram-testa-capacidade-de-silenciar-perfis?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A rede social quer introduzir uma nova funcionalidade]]></description>
                                            <content:encoded><![CDATA[<p>O Instagram está testando uma série de novas funcionalidades. Entre elas, a possibilidade de ‘silenciar’ perfis. Assim, será possível deixar de ver as postagens de determinada pessoa sem que seja preciso parar de seguir o usuário. </p>

<p>Como lembra o CanalTech, não é preciso se preocupar que a pessoa "silenciada" saiba o que aconteceu, pois não terá como descobrir. A função se assemelha com a de deixar de seguir alguém no Facebook, ainda mantendo a "amizade virtual". </p>
<p>Estão também a ser testados atalhos no Instagram, como os de acessar funcionalidades sem entrar no app na versão para Android Oreo. Os quatro atalhos disponíveis têm o objetivo de dar acesso a partes diferentes da rede social, seja à área de mensagens diretas, seja à capacidade de publicar sem entrar no aplicativo.</p>
<p>Por último, o Instagram também está trabalhando em uma forma de guardar os Stories por via de um calendário, lembrando quando publicou determinado vídeo.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585752/instagram-stories-serao-integradas-a-spotify-e-gopro" target="_blank">Instagram: stories serão integradas a Spotify e GoPro</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 21:36:57 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae2124bc8209.jpg?1525307857" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Bombeiros usam câmera térmica em resgate de vítimas de desabamento]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585416/bombeiros-usam-camera-termica-em-resgate-de-vitimas-de-desabamento?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585416/bombeiros-usam-camera-termica-em-resgate-de-vitimas-de-desabamento?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Equipamento verifica a temperatura em lugares onde ainda podem existir focos de incêndio]]></description>
                                            <content:encoded><![CDATA[<p>Após um incêndio ter ocasionado o desabamento de um prédio no Centro de São Paulo, nessa terça-feira (1º), o Corpo de Bombeiros está trabalhando intensamente para encontrar sobreviventes e corpos das vítimas sob os escombros.</p>

<p>Ao menos 118 famílias viviam no local, que estava ocupado por pessoas que não tinham moradia. Os bombeiros informaram que há 44 desaparecidos.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/585339/apple-respira-aliviada-vendas-de-iphone-voltam-a-subir" target="_blank">+ Apple respira aliviada: vendas de iPhone voltam a subir</a></p>
<p>Além de cães farejadores, as equipes de busca se utilizam de tecnologia para localizar as vítimas o mais rápido possível. Com uma câmera térmica, os profissionais conseguem identificar silhuetas de pessoas e animais, através da irradiação de calor de seus corpos; ou até mesmo verificar a temperatura nos lugares onde ainda podem existir focos de incêndio.</p>
<p>O primeiro-tenente Guilherme Derrite, porta-voz do Corpo de Bombeiros, contou ao UOL que esta segunda situação é a que ocorre em São Paulo. "Nos locais onde a temperatura é mais alta, a gente recebe essa informação pela câmera, em graus centígrados, e centraliza os esforços de resfriamento nessas zonas quentes. Depois disso, os cães farejadores podem entrar sem problema", explicou.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 18:55:05 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae9c9e10a17c.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Último artigo de Hawking tenta definir origem do Universo]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585647/ultimo-artigo-de-hawking-tenta-definir-origem-do-universo?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585647/ultimo-artigo-de-hawking-tenta-definir-origem-do-universo?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Podem existir vários universos, mas estes não seriam assim tão diferentes]]></description>
                                            <content:encoded><![CDATA[<p>A revista científica ‘The Journal of High-Energy Physics’ publicou no dia 1º de maio o último artigo da autoria de Stephen Hawking, enviado ao periódico dez dias antes da morte do cientista. O ensaio, chamado <a href="https://link.springer.com/article/10.1007/JHEP04%282018%29147" target="_blank">‘Uma saída simples da inflação eterna’</a>, debruça-se sobre o que aconteceu após o Big Bang.</p>

<p>Até o momento, a corrente teórica mais aceita é a de que o Universo foi criado com o Big Bang e se transformou naquilo que é hoje através de uma expansão rápida, conhecida como inflação. Essa inflação, entretanto, dentro dos limites do mensurável, teria cessado há muito tempo.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/585591/pivo-de-polemica-sobre-privacidade-no-facebook-vai-fechar-diz-jornal" target="_blank">Pivô de polêmica sobre privacidade no Facebook vai fechar, diz jornal</a></p>
<p>No entanto, outras teorias dizem que ela nunca parou, continuando como uma onda e afetando outras regiões do cosmos. Esta teoria poderia implicar na existência de uma multiplicidade de universos.</p>
<p>Partindo desse princípio, tem-se as questões: quão diferentes são do nosso e o que é que isso significa para as leis da natureza, que são medidas apenas mediante aquilo que é possível observar? Para Hawking, porém, a inflação eterna não era credível, embora ele defendesse a existência de mais do que um universo.</p>
<p>Nesta nova explanação de hipóteses, que fez juntamente com o físico belga Thomas Hertog, <span class="news_bold">Hawking propõe que o Big Bang poderia ter dado, sim, origem a uma multiplicidade de universos, mas que a variedade não é grande, porque todos eles partilham de regras físicas semelhantes ao planeta Terra.</span></p>
<p>“Presumimos que a saída da inflação eterna não produziu um multiverso infinito e fractal, mas finito e razoavelmente simples”, escreve ele.</p>
<p>David Kaiser, do Instituto de Tecnologia de Massachusetts, explicou a conclusão da teoria à <a href="http://time.com/5263203/stephen-hawking-last-physics-paper/" target="_blank">revista TIME</a> da seguinte forma: <span class="news_bold">“O comportamento do nosso Universo, que é observável, poderia não ser uma raridade atípica, mas talvez relativamente comum. Naturalmente, isto é tudo bastante especulativo”</span>.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 17:41:33 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5aa9bc5bc7317.jpg?1525293726" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Messenger fica mais simples e ganha novas funcionalidades; confira]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585457/messenger-fica-mais-simples-e-ganha-novas-funcionalidades-confira?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585457/messenger-fica-mais-simples-e-ganha-novas-funcionalidades-confira?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[App de mensagem do Facebook vai priorizar conversas e possibilitar personalização, além de ganhar 'm]]></description>
                                            <content:encoded><![CDATA[<p>Mark Zuckerberg, o CEO do Facebook, anunciou nessa terça-feira (1º), durante a abertura da F8, conferência anual de desenvolvedores da rede social, que uma nova versão do Messenger vai ser disponibilizada em breve. De acordo com ele, o app deve ficar ainda mais simples, e as mensagens de texto devem aparecer em primeiro lugar.</p>

<p>A página inicial do aplicativo exibirá as conversas mais recentes. Na parte inferior, haverá botões para criação de novas conversas, grupos e stories. Os itens para tirar foto e gravar vídeo com a câmera do Messenger ficarão na parte superior direita da tela.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/585293/whatsapp-vai-ganhar-stickers-e-videochamadas" target="_blank">+ WhatsApp vai ganhar 'stickers' e videochamadas</a></p>
<p>O novo Messenger também contará com o "modo noturno", que deixa o fundo preto e o texto branco. Além da cor preta oferecer mais contraste em telas OLED, gasta menos bateria.</p>
<p>Também será possível customizar individualmente as cores dos balões de mensagem das conversas, para facilitar a identificação.</p>
<p>Segundo o The Verge, o novo design do Messenger deve chegar "muito, muito em breve".</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 15:56:58 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae9d75ef41d5.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[65 bilhões de mensagens são enviadas pelo WhatsApp diariamente]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585513/65-bilhoes-de-mensagens-sao-enviadas-pelo-whatsapp-diariamente?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585513/65-bilhoes-de-mensagens-sao-enviadas-pelo-whatsapp-diariamente?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[App também faz 2 bilhões de minutos em chamadas]]></description>
                                            <content:encoded><![CDATA[<p>O WhatsApp acaba de atingir a marca de mais de 65 bilhões de mensagens diárias, além de 2 bilhões de minutos em chamada de vídeo e áudio. O anúncio foi feito pelo Facebook -empresa detentora da marca - durante a F8, conferência anual de desenvolvedores da rede social.</p>

<p>Ainda de acordo com o Facebook, até mesmo a função status do WhatsApp (semelhante ao Instagram Stories e ao Snapchat), que parece não ter implacadao, teve 450 milhões de pessoas usando todos os dias. Em janeiro deste ano, o app de mensagens possuía 1,5 bilhão de usuários mensais ativos.</p>
<p>Como lembra o TecMundo, a empresa está passando por um momento delicado. O criador e presidente do WhatsApp, Jan Koum, anunciou a sua saída do Facebook após os escândalos de privacidade que atingiram a rede social.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585457/messenger-fica-mais-simples-e-ganha-novas-funcionalidades-confira" target="_blank">Messenger fica mais simples e ganha novas funcionalidades; confira</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 13:40:56 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a7aefc40558c.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Apple respira aliviada: vendas de iPhone voltam a subir]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585339/apple-respira-aliviada-vendas-de-iphone-voltam-a-subir?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585339/apple-respira-aliviada-vendas-de-iphone-voltam-a-subir?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Por conta da alta dos preços do produto, vendas aumentaram 3%; já o faturamento saltou 14%]]></description>
                                            <content:encoded><![CDATA[<p>A Apple apresentou nessa terça-feira (1º) os resultados trimestrais da empresa. Após registrar queda nas vendas no lançamento do iPhone X, a marca reagiu. Nos três primeiros meses deste ano, a Apple registrou um crescimento de 16% em comparação com o mesmo período de 2017.</p>

<p>A empresa fechou o trimestre com receita de 61,14 bilhões de dólares. O salto contribuiu para um lucro líquido de 13,82 bilhões no período.</p>
<p>Como pontua o Olhar Digital, boa parte do rendimento se deve à alta nas vendas do iPhone, que teve 52,22 milhões de unidades vendidas e contribuiu com uma receita total de 38,03 bilhões de dólares.</p>
<p>As vendas da empresa aumentaram 3%, enquanto o faturamento saltou 14%. A diferença reflete o aumento no preço médio do iPhone.</p>
<p>O iPad também se recuperou depois de amargurar anos de quedas consecutivas. O lançamento de tablets mais baratos e da linha Pro, para usuários mais avançados, surtiu efeito. No total, foram vendidos 9,11 milhões de iPads no período, que corresponde a 2% de aumento na comparação ano a ano e a 6% na contribuição para as receitas da empresa.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/585034/novo-iphone-e-o-queridinho-dos-brasileiros" target="_blank">+ Novo iPhone é o queridinho dos brasileiros</a></p>
<p>O Mac, ao contrário dos demais produtos, teve uma leve queda de 3% nas vendas, mas o faturamento praticamente não se alterou.</p>
<p>Os dados revelaram ainda que a área que mais tem crescido na marca não é a de produtos, mas sim os serviços: Apple Music, Apple Pay e venda de aplicativos pela App Store e conteúdo da iTunes Store. As receitas subiram 31% em um ano e chegaram a 9,19 bilhões de dólares.</p>
<p>A categoria “Outros Produtos”, que engloba Apple TV, HomePod, Apple Watch, iPod e outros acessórios, também apresentou um rápido crescimento de 38%, chegando a 3,95 bilhões de dólares.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 08:53:06 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae9a6b76bb7a.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Facebook responde à polêmica da Cambridge Analytica com um novo botão]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585275/facebook-responde-a-polemica-da-cambridge-analytica-com-um-novo-botao?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585275/facebook-responde-a-polemica-da-cambridge-analytica-com-um-novo-botao?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Opção 'Apagar Histórico' permitirá ao usuário deletar os dados de navegação na rede social]]></description>
                                            <content:encoded><![CDATA[<p>Depois da polêmica envolvendo a consultoria Cambridge Analytica e a apropriação de dados de 87 milhões de usuários do Facebook, a rede social criou um novo botão que permitirá apagar todo o histórico de navegação.</p>

<p>“Assim que lançarmos, esta atualização será capaz de ver toda a informação sobre as apps e sites com que interagiu e poderá apagar esta informação da tua conta. Será possível também impedir que esta informação seja armazenada na sua conta”, explicou o CEO do Facebook Mark Zuckerberg.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/585240/videochamadas-chegaram-ao-instagram" target="_blank">+ Videochamadas chegaram ao Instagram</a></p>
<p>Como nota o The Next Web, isto não significa que o Facebook deixará de coletar dados sobre a navegação dos utilizadores.</p>
<p>De acordo com a responsável pela divisão de privacidade da rede social, Erin Egan, o Facebook ainda vai dividir com desenvolvedores “se as os seus aplicativos são mais populares entre homens ou mulheres em determinadas faixas etárias”, garantindo que isto será feito “sem armazenar informação associada às contas” e “sem dizer aos anunciantes quem são os usuários”.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 07:11:07 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae98ac2622b3.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Videochamadas chegaram ao Instagram]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585240/videochamadas-chegaram-ao-instagram?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585240/videochamadas-chegaram-ao-instagram?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A área Explore também foi redesenhada para ficar mais intuitiva]]></description>
                                            <content:encoded><![CDATA[<p>O Instagram lançou nesta quarta-feira (2), para um grupo restrito de usuários, a capacidade de realizarem videochamadas diretamente através do aplicativo, naquela que é uma aposta clara na vertente de comunicação da rede social.</p>

<p>A opção ainda está em fase de testes, mas o lançamento global já está prometido para breve.</p>
<p>Caso você já tenha a capacidade de realizar as chamadas por vídeo (seja só com uma pessoa ou com um pequeno grupo), poderá fazê-lo através do ícone de avião de papel, localizado no canto superior direito, premindo o símbolo ‘+’ e selecionando duas ou mais pessoas para a chamada.</p>
<p>Esta não é a única novidade do Instagram, que aproveitou a oportunidade para redesenhar a sua página Explore para mostrar mais páginas relacionadas com os seus interesses. Esta alteração também irá começar a chegar gradualmente aos usuários nas próximas semanas.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585087/curioso-sobre-um-candidato-app-revela-os-politicos-encrencados" target="_blank">Curioso sobre um candidato? App revela os políticos encrencados</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 05:40:15 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ab3d9f8a8659.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Curioso sobre um candidato? App revela os políticos encrencados]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585087/curioso-sobre-um-candidato-app-revela-os-politicos-encrencados?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585087/curioso-sobre-um-candidato-app-revela-os-politicos-encrencados?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Plataforma criada pelo Reclame Aqui disponibiliza informações da Justiça sobre passado de deputados,]]></description>
                                            <content:encoded><![CDATA[<p>As eleições de 2018 estão logo aí. Você já sabe em quem vai votar? Tem dúvidas sobre um determinado candidato? Pois um aplicativo para celular promete dar informações sobre os políticos brasileiros que têm processos na Justiça.</p>

<p>Através de análise de fotos, o Detector de Corrupção possibilita relacionar todas as pendências acumuladas durante a vida pública, informa o Metrópoles.</p>
<p>Após o usuário baixar o app, basta fotografar o rosto do político em santinhos, vídeos ou redes sociais, e a ferramenta faz o reconhecimento facial com até 98% de precisão, segundo os desenvolvedores. O sistema então, ao acessar o banco de dados interligados aos tribunais do país, identifica quais processos na Justiça estão atrelados ao nome.</p>
<p>Em teste realizado pelo site com os 13 pré-candidatos ao Palácio do Buriti, somente três cadastrados na plataforma não têm contestações jurídicas.</p>
<p>O Metrópoles testou a nova ferramenta com os pré-candidatos ao governo do Distrito Federal. De treze políticos, apenas três cadastrados na plataforma não têm contestações jurídicas: o atual governador do Distrito Federal, Rodrigo Rollemberg (PSB), o distrital Chico Leite (Rede) e o herdeiro da rede Giraffas, Alexandre Guerra (Novo).</p>
<p>Outros cinco possuem registros de improbidade administrativa, e sete não foram reconhecidos pelo sistema após pesquisa por meio de retratos.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585070/twitter-tambem-vendeu-dados-para-pesquisador-da-cambridge-analytica" target="_blank">Twitter também vendeu dados para pesquisador da Cambridge Analytica</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Wed, 02 May 2018 05:11:40 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ac0adc5dd2ab.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Facebook reforça controle parental na sua app de mensagens]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585091/facebook-reforca-controle-parental-na-sua-app-de-mensagens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585091/facebook-reforca-controle-parental-na-sua-app-de-mensagens?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Messenger Kids acaba de ganhar um mood ‘sleep’ que poderá ser ativado para impedir acesso dos mais n]]></description>
                                            <content:encoded><![CDATA[<p>O Facebook implementou novas opções de controle parental no seu aplicativo de mensagens dedicada a crianças, o Messenger Kids, destinadas a limitar o tempo que os mais novos passam dentro da aplicação.</p>

<p>Uma destas opções é o modo ‘Sleep’. Com esta opção os pais podem escolher as horas em que o app deixa de funcionar, permitindo assim, impor mais facilmente horas de dormir em dias de semana.</p>
<p>Apesar destas opções, ainda há quem defenda que o Facebook não deveria lançar apps especificamente para crianças, recorda a Time.</p>
<p>Até o momento, o Messenger Kids apenas está disponível em determinados territórios, sendo de esperar que venha a ser lançado em mais à medida que a ferramenta seja desenvolvida.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/585087/curioso-sobre-um-candidato-app-revela-os-politicos-encrencados" target="_blank">Curioso sobre um candidato? App revela os políticos encrencados</a></span></p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 01 May 2018 13:25:38 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae6efe23d3a2.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Twitter também vendeu dados para pesquisador da Cambridge Analytica]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585070/twitter-tambem-vendeu-dados-para-pesquisador-da-cambridge-analytica?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585070/twitter-tambem-vendeu-dados-para-pesquisador-da-cambridge-analytica?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Rede social confirma o acesso da GSR em 2015]]></description>
                                            <content:encoded><![CDATA[<p>Depois do Facebook, uma nova polêmica surge sobre compartilhamento de dados envolvendo a companhia de consultoria política Cambridge Analytica. Aleksandr Kogan, mesmo acadêmico que esteve no centro do caso da rede social de Mark Zuckerberg, também comprou acesso a dados do Twitter para utilizar em sua firma, a Global Science Research (GSR), noticia o Tec Mundo.</p>

<p>Kogan foi o responsável por criar ferramentas à Cambridge Analytica para que a empresa pudesse perfilar psicologicamente os eleitores durante o pleito de Donald Trump, em 2016.</p>
<p>Segundo o jornal Telegraph, o pesquisador comprou pacote do Twitter Em 2015. Kogan se defende alegando que as informações colhidas teriam sido usadas apenas para elaborar "relatórios de marcas” e “recursos extensores de pesquisas” e que não violou nenhuma das regras do microblog.</p>
<p>A Cambridge Analytica afirmou ter usado a rede social para publicidade política, informou um porta-voz da empresa. No entanto, garante que a companhia nunca "empreendeu um projeto com a GSR se concentrando em dados do Twitter e a Cambridge Analytica nunca recebeu dados do Twitter da GSR”.</p>
<p>Ele acrescentou que "a Cambridge Analytica é uma agência de marketing orientada por dados e não 'manipula visões políticas'".</p>
<p><span class="news_bold">+ <a href="https://www.noticiasaominuto.com.br/tech/585034/novo-iphone-e-o-queridinho-dos-brasileiros" target="_blank">Novo iPhone é o queridinho dos brasileiros</a></span></p>
<p>O Twitter confirma o acesso da GSR em 2015. "Em 2015, a GSR teve um acesso único a uma amostra aleatória de tweets públicos de um período de cinco meses, de dezembro de 2014 a abril de 2015. Com base nas informações que vieram a público, conduzimos nossa própria revisão interna e não descobrimos qualquer acesso a dados privados de pessoas que usam o Twitter”, disse ao Bloomberg uma fonte interna da rede social.</p>
<p>“O Twitter tomou a decisão política de excluir a publicidade de todas as contas de propriedade e operadas pela Cambridge Analytica. Essa decisão é baseada em nossa crença de que a Cambridge Analytica esteja operando um modelo de negócios intrinsecamente conflitante com as práticas comerciais aceitáveis do Twitter Ads”, comunicou um porta-voz.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 01 May 2018 12:20:11 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_59cd942264eaa.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Novo iPhone é o queridinho dos brasileiros]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585034/novo-iphone-e-o-queridinho-dos-brasileiros?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585034/novo-iphone-e-o-queridinho-dos-brasileiros?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[iPhone X tem 85% de satisfação entre usuários]]></description>
                                            <content:encoded><![CDATA[<p>De acordo com uma pesquisa feita pela Creative Strategies, o iPhone X tem 85% de aprovação entre seus usuários. O design do smartphone e a velocidade são recursos bem avaliados, e a qualidade das fotos possui nível de aprovação acima de 90%.</p>

<p>Com a menor nota está Siri, a assistente virtual do iOS, somando apenas 20% de aprovação.</p>
<p>Mesmo com tamanha satisfação, o smartphone não é o mais comercializado pela Apple nos Estados Unidos. Conforme noticia o Tech Tudo, o iPhone 8 e o iPhone 8 Plus lideram as vendas no território norte-americano no primeiro trimestre de 2018, com 44%. O iPhone X alcança apenas 16%, de acordo com a Consumer Intelligence Research Partners (CIRP).</p>
<p>A pesquisa da Creative Strategies avaliou também recursos exclusivos do iPhone X, como suporte a gestos para substituir o botão de início e o Face ID, tecnologia de desbloqueio facial, que alcançaram boas notas de aprovação, acima de 90%.</p>
<p>Em relação ao Modo Retrato, que aplica efeitos de profundidade e iluminação, a recepção também foi boa entre os usuários. No entanto, para selfies, a satisfação do recurso fica abaixo dos 70%. Este foi o recurso mais anunciado pela empresa para promover o novo modelo.</p>
<p><span class="news_bold">+ <a href="https://www.noticiasaominuto.com.br/tech/584993/telegram-e-bloqueado-no-ira" target="_blank">Telegram é bloqueado no Irã</a></span></p>
<p>Segundo a pesquisa, a Siri foi o recurso que mais decepcionou os usuários, com apenas 20% de aprovação. Mesmo tendo sido uma das primeiras empresas a levar uma assistente virtual para um smartphone, outros concorrentes evoluíram mais rápido que a Apple, como a Alexa, da Amazon, e a Google Assistente.</p>
<p>Durante o lançamento do iPhone X, um adas principais reclamações foi o valor, tido como caro até mesmo para os padrões americanos. Os preços iniciam em US$ 999, contra US$ 699 do iPhone 8 e US$ 749 do iPhone 8 Plus. No Brasil, o iPhone X custa a partir de R$ 6.999.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 01 May 2018 10:05:24 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a0f2404a6838.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Inclusão digital exige renovação de pontos públicos de internet]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/585002/inclusao-digital-exige-renovacao-de-pontos-publicos-de-internet?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/585002/inclusao-digital-exige-renovacao-de-pontos-publicos-de-internet?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[46% dos lares brasileiros ainda estão desconectados]]></description>
                                            <content:encoded><![CDATA[<p>Mesmo com o aumento no número de domicílios brasileiros conectados à internet, os centros de inclusão digital ainda são constantemente usados por aqueles que não têm nem computador nem banda larga fixa em casa.</p>

<p>De acordo com a última pesquisa TIC Domicílios (2016), que mede o acesso às Tecnologias da Informação e da Comunicação (TIC), 46% dos lares brasileiros ainda estão desconectados. O índice sobe para 54% entre as famílias com</p>
<p>Em São Paulo, o Acessa SP oferece à população, gratuitamente, acesso a computadores com internet e contam ainda com o auxílio de instrutores. Os cidadãos que frequentam podem pesquisar diversos assuntos, estudar, procurar emprego e ainda fazer cursos<em> on-line</em> como o Trilhas do Conhecimento, dirigido aos jovens que concluíram ou concluirão o ensino médio, com orientações sobre temas voltados ao desenvolvimento profissional e pessoal.</p>
<p>Algumas unidades ainda oferecem impressão de documentos, serviço muito usado para quem precisar imprimir um currículo profissional, por exemplo. O programa existe há 18 anos, nesse período cadastrou 3,430 milhões de pessoas e realizou 98 milhões de atendimentos. Atualmente há 496 postos em funcionamento em todo o estado, a maioria funciona em parceria com as prefeituras.</p>
<p><strong>Telecentros</strong></p>
<p>Com unidade em todo o Brasil, os telecentros do governo federal oferecem cursos e atividades e funcionam como espaço de integração, cultura e lazer. Os frequentadores também contam com assistência de monitores.</p>
<p>Segundo o Portal Governo Digital, existem 7.755 telecentros, instalados por meio de parceria entre ministérios, prefeituras e entidades, que são responsáveis pela manutenção desses espaços.</p>
<p> </p>
<p>Segundo a pesquisa anual feita com usuários do AcessaSP, 41% estavam sem trabalho e procurando emprego pela internet e 60% foram a um posto, nos últimos 12 meses, para atividades profissionais. A pesquisa mostrou ainda que 58,67% dos usuários têm renda familiar até dois salários-mínimos e 52,86% têm computador (desktop, laptop ou netbook) em casa, mas apenas 22,46% têm internet.</p>
<p><span class="news_bold">+ <a href="https://www.noticiasaominuto.com.br/tech/584961/cofundador-do-whatsapp-decide-se-afastar-do-facebook-apos-escandalo" target="_blank">Cofundador do WhatsApp decide se afastar do Facebook após escândalo</a></span></p>
<p><strong>Desafios da inclusão digital</strong></p>
<p>Segundo os dados da TIC Domicílios, a internet móvel é a principal forma de conexão em 9,3 milhões de residências, principalmente entre as classes D e E, na Região Norte e nas áreas rurais. Mesmo com a popularização do uso da internet no celular, os telecentros continuam desempenhando um papel importante para a inclusão digital, pois alguns serviços, como montar um currículo ou escrever uma redação, por exemplo, ainda dependem de um computador.</p>
<p>Mas a inclusão social requer mais do que ofertar computadores e internet de graça. O processo de democratização do acesso às tecnologias da Informação deve permitir a inserção de todos na sociedade da informação. </p>
<p>Desde que o Marco Civil da Internet foi aprovado, em 2014, o acesso à internet é considerado um serviço essencial para todos e condição fundamental de garantia da cidadania. Cada dia mais, aspectos da vida cotidiana dos cidadãos dependem da conexão à rede, por exemplo, o pagamento de contas, o acompanhamento sistemático da gestão pública e até mesmo a inscrição em concursos públicos. Com informações da Agência Brasil.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 01 May 2018 08:50:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a23fda091374.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Telegram é bloqueado no Irã]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584993/telegram-e-bloqueado-no-ira?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584993/telegram-e-bloqueado-no-ira?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Decisão se deve ao dano provocado pelo sistema de mensagens na segurança e economia do país]]></description>
                                            <content:encoded><![CDATA[<p>O Irã bloqueou nesta terça-feira (1º) o aplicativo de mensagens Telegram, muito usado no país, depois de semanas de polêmica sobre o futuro do app, acusada de danificar a segurança nacional.</p>

<p>O acesso à plataforma permanece hoje bloqueado, numa nova medida das autoridades para controlar as redes sociais no país iraniano, onde o Facebook e o Twitter também estão suspensos.</p>

<p>A justiça iraniana decretou na noite de segunda-feira (30) a proibição do uso do Telegram e ordenou aos servidores da Internet que bloqueiem "completamente" o acesso.</p>
<p>Segundo um comunicado divulgado pelo poder judicial iraniano, a decisão se deve ao dano provocado pelo sistema de mensagens na segurança e economia do país durante os últimos anos.</p>
<p>A rede social tem cerca de 40 milhões de usuários no Irã e foi uma das ferramentas usadas para convocar os protestos em dezembro passado contra a subida de preços e a corrupção. Com informações da Lusa.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/584975/apple-pode-perder-fatia-de-mercado-na-china" target="_blank">Apple pode perder fatia de mercado na China</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Lusa</dc:creator>
                    <pubDate>Tue, 01 May 2018 07:50:05 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/24099098.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Vídeo mostra versão 'concept' do Galaxy Note 9]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584949/video-mostra-versao-concept-do-galaxy-note-9?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584949/video-mostra-versao-concept-do-galaxy-note-9?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Modelo top de linha da Samsung é esperado para o segundo semestre]]></description>
                                            <content:encoded><![CDATA[<p>O aspecto final do Galaxy Note 9 ainda é mistério, o que não significa que não haja ninguém disposto a apostar no design final que a Samsung adotará para o modelo top de linha. O vídeo acima do Science and Knowledge te dá uma ideia do que esperar.</p>

<p>Vale notar que o smartphone mostrado no vídeo não é a versão final do Galaxy Note 9. O aparelho só está previsto para o segundo semestre, pelo que ainda não é conhecido o aspecto do dispositivo propriamente dito. Ainda assim, o ‘concept’ apresentado no vídeo permite tirar algumas ideias.</p>
<p>É provável que a Samsung voltará a apostar num dispositivo com moldura de monitor reduzido, com rumores que incluirá um sensor de impressões digitais na própria tela.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 01 May 2018 06:25:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae6f8feeb606.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Apple pode perder fatia de mercado na China]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584975/apple-pode-perder-fatia-de-mercado-na-china?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584975/apple-pode-perder-fatia-de-mercado-na-china?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Vários analistas continuam apontando para uma presença cada vez mais fraca no território]]></description>
                                            <content:encoded><![CDATA[<p>De acordo com três analistas citados pelo Business Insider, a Apple pode ter perdido definitivamente o território chinês. Um deles, a Morgan Stanley, aponta que a tecnológica tem apenas 18% de quota de mercado na China, deixando o cenário cada vez mais magro.</p>

<p>Tendo em conta que em 2015, a ‘Empresa da Maçã’ contava com uma fatia de mercado entre os 40% e os 50% na China, a queda é considerável e preocupante para os investigadores. É de ressaltar que mesmo a Samsung tem tido dificuldades em manter-se à tona no território chinês.</p>
<p>O motivo está nas concorrentes da companhia liderada por Tim Cook no território chinês, mais precisamente a Oppo, a Vivo, Xiaomi e a Huawei, que aparentemente conseguiram convencer os consumidores com os seus preços mais convidativos.</p>
<p><span class="news_bold">Leia também: <a href="https://www.noticiasaominuto.com.br/tech/584961/cofundador-do-whatsapp-decide-se-afastar-do-facebook-apos-escandalo" target="_blank">Cofundador do WhatsApp decide se afastar do Facebook após escândalo</a></span></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Tue, 01 May 2018 06:10:14 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5559d49525aed.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Cofundador do WhatsApp decide se afastar do Facebook após escândalo]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584961/cofundador-do-whatsapp-decide-se-afastar-do-facebook-apos-escandalo?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584961/cofundador-do-whatsapp-decide-se-afastar-do-facebook-apos-escandalo?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Jan Koum anunciou sua demissão num post na rede social]]></description>
                                            <content:encoded><![CDATA[<p>O homem que vendeu o WhatsApp para o Facebook e se tornou um dos executivos mais poderosos na rede social de Mark Zuckerberg está deixando a empresa.</p>

<p>Jan Koum, que ganhou o equivalente a R$ 66 bilhões quando vendeu o app de mensagens, decidiu se afastar da gigante do Vale do Silício por preocupações sobre a segurança de dados, dizem pessoas próximas à negociação.</p>
<p>De acordo com executivos do Facebook, Koum acreditava que a rede social tinha dados demais sobre seus usuários e vinha pressionando para que a empresa aumentasse mecanismos de controle sobre essas informações, dando sinais de que deixaria o cargo desde o ano passado.</p>
<p>O escândalo da Cambridge Analytica, a consultoria política que usou dados de 87 milhões de clientes do Facebook para manipular as últimas eleições presidenciais americanas a favor de Donald Trump há dois anos parece ter sido o estopim de sua saída.</p>
<p>Koum, que anunciou sua demissão num post no Facebook dizendo que "é hora de seguir adiante", é o nome mais importante a deixar a firma de Zuckerberg desde a revelação de vazamentos de dados.</p>
<p>Em março, o jornal The New York Times também noticiou que Alex Stamos, o chefe de segurança da rede social, tem intenções de deixar seu cargo.</p>
<p>O episódio da Cambridge Analytica também levou o Facebook a fazer mudanças no alto escalão, mudando equipes em Washington, onde seus lobistas trabalham para influenciar decisões de governo.</p>
<p>Brian Acton, que fundou o WhatsApp com Koum, disse em março que era hora de deletar o Facebook, engrossando um movimento de boicote à rede social que está ganhando força desde o escândalo da Cambridge Analytica. Com informações da Folhapress.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Folhapress</dc:creator>
                    <pubDate>Tue, 01 May 2018 05:46:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae7c4ce723c1.jpg?1525138676" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Sem tempo? Saiba como usar as respostas automáticas do WhatsApp]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584691/sem-tempo-saiba-como-usar-as-respostas-automaticas-do-whatsapp?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584691/sem-tempo-saiba-como-usar-as-respostas-automaticas-do-whatsapp?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Ferramenta pode ser especialmente útil para quem está sempre na correria]]></description>
                                            <content:encoded><![CDATA[<p>Caso esteja na correria, saiba que o WhatsApp disponibiliza algumas "respostas automáticas" para quem não tem tempo para atender uma ligação no aplicativo. Mas, por enquanto, apenas usuários do sistema Android podem se dar este luxo.</p>

<p>Segundo o 'Techtudo', este recurso fica um tanto "escondidinho" no mensageiro. Para ativar, clique no ícone de "balão de chat" ao receber uma ligação. Em seguida, selecione uma das respostas automáticas como "Já te ligo de volta" ou "Não posso falar agora. O que me conta?". Por fim, a mensagem é enviada de forma automática na conversa com o contato que fez a ligação.</p>
<p>Pense que esta função pode ser especialmente útil para quem esta no meio de uma reunião de trabalho. Assim fica muito mais prático, não?</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/584537/nasa-finaliza-desenvolvimento-do-unico-veiculo-lunar" target="_blank">NASA finaliza desenvolvimento do único veículo lunar</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 30 Apr 2018 13:26:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a586fece6738.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Agora vai: Facebook amplia teste do botão 'não gostei']]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584815/agora-vai-facebook-amplia-teste-do-botao-nao-gostei?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584815/agora-vai-facebook-amplia-teste-do-botao-nao-gostei?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Recurso começou a aparecer para usuários fora dos Estados Unidos]]></description>
                                            <content:encoded><![CDATA[<p>Como reagir de forma negativa a uma publicação do Facebook com as opções hoje disponíveis na rede social? É por essas e outras que o botão "não gostei" é tão aguardado - mais precisamente desde fevereiro, quando começaram os testes do "dislike" nos Estados Unidos.</p>

<p>Agora, parece que a rede social está liberando o recurso em outras regiões do mundo. De acordo com o 'UOL', o "downvote" já apareceu para usuários da Nova Zelândia e da  Austrália.</p>
<p>Imagens compartilhadas nas redes sociais mostram que a ferramenta envolve uma seta para cima, de "curti", e outra para baixo, de "não curti" ao lado dos comentários nos posts.</p>
<blockquote class="twitter-tweet" data-lang="pt">
<p dir="ltr" lang="en">Upvote and downvote comments on Facebook, when did this happen? <a href="https://t.co/q9F7OcJ4R3">pic.twitter.com/q9F7OcJ4R3</a></p>
— Carter (@cwsbbb) <a href="https://twitter.com/cwsbbb/status/990511270146162688?ref_src=twsrc%5Etfw">29 de abril de 2018</a></blockquote>
<p>
<script charset="utf-8" src="https://platform.twitter.com/widgets.js" async=""></script>
</p>
<p>A rede social diz que a ferramenta não é para funcionar como um recurso de "antipatia", mas sim, como um indicador do que as pessoas gostam de ler, ou não. Além disso, estima-se que o "downvote" poderia ajudar a tornar as postagens mais ou menos relevantes.</p>
<p>"Nossa esperança é que esse recurso torne mais fácil para nós criarmos esses espaços, classificando os comentários que os leitores acreditam que merecem ser mais bem classificados, do que os comentários que obtêm a mais forte reação emocional", disse um porta-voz da rede social em entrevista à BBC.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/584691/sem-tempo-saiba-como-usar-as-respostas-automaticas-do-whatsapp" target="_blank">Sem tempo? Saiba como usar as respostas automáticas do WhatsApp</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 30 Apr 2018 13:03:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae73d490bb9d.jpg?1525289432" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Microsoft lança teste do Office 2019 com mudanças no Word, Excel e mais]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584767/microsoft-lanca-teste-do-office-2019-com-mudancas-no-word-excel-e-mais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584767/microsoft-lanca-teste-do-office-2019-com-mudancas-no-word-excel-e-mais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Por enquanto, pacote está disponível em programas para empresas]]></description>
                                            <content:encoded><![CDATA[<p>O programa de testes do Office 2019 já começou para empresas, com atualizações para Word, Excel, Power Point, Outlook e outros programas. De acordo com o 'Techtudo', só será possível acessar o pacote com o Windows 10.</p>

<p>A novidade vai melhorar o desempenho de escrita da caneta eletrônica em tablets e notebooks híbridos, melhorando a sensibilidade à pressão, efeitos de inclinação e replay de desenhos.</p>
<p>+<a href="https://www.noticiasaominuto.com.br/tech/584691/sem-tempo-saiba-como-usar-as-respostas-automaticas-do-whatsapp" target="_blank"> Sem tempo? Saiba como usar as respostas automáticas do WhatsApp</a></p>
<p>Ainda segundo a reportagem, processador de planilhas do Windows vai contar com novos gráficos e fórmulas. O Excel vai aprofundar a capacidade de análise de dados, para garantir uma experiência mais útil aos usuários. E o Power Point deverá receber o recurso de Zoom nas apresentações.</p>
<p><a href="https://support.microsoft.com/en-us/help/4133311/how-to-participate-in-the-office-2019-commercial-preview-program" target="_blank">Clique aqui</a> para saber mais informações sobre o programa de testes do Office 2019.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 30 Apr 2018 11:36:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae72afa53198.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Advogado cria app para ajudar dependentes de álcool e drogas]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584742/advogado-cria-app-para-ajudar-dependentes-de-alcool-e-drogas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584742/advogado-cria-app-para-ajudar-dependentes-de-alcool-e-drogas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Plataforma oferece 1.200 endereços de entidades que prestam assistência a essas pessoas]]></description>
                                            <content:encoded><![CDATA[<p>O anonimato é uma das garantias que dependentes de álcool e drogas buscam ao pedir ajuda. Sabendo disso, o advogado Paulo Leme Filho, de 46 anos, desenvolveu um aplicativo que oferece 1.200 endereços de entidades que prestam assistência a essas pessoas no Estado de São Paulo. Lançada neste mês, a ferramenta "Eu me Importo" mostra as instituições mais próximas utilizando como base CEP ou endereço e também a localização da pessoa.</p>

<p>Leme Filho é um conhecedor do tema. Está há 21 anos em abstinência e acompanhou o vício do pai, que está há 29 anos sem beber. O advogado reuniu a experiência que ele e o pai, que está com 77 anos, tinham com o vício e, juntos, escreveram o livro "A Doença do Alcoolismo" (Scortecci Editora), que foi lançado em 2015. A partir do livro, pai e filho começaram a fazer palestras gratuitas em escolas e montaram a ONG Movimento Vale a Pena.</p>
<p>Em suas palestras, Leme Filho costuma se deparar com muitas dúvidas e diz que as pessoas não se sentem à vontade para conversar e pedir informações sobre os grupos de ajuda para dependentes de álcool e drogas. Por essa razão, ele resolveu desenvolver o aplicativo, que funciona como uma fonte para quem busca um desses endereços. "O objetivo é unificar os grupos em um aplicativo anônimo, porque, fora desses grupos, é muito difícil largar o álcool e as drogas. A partir do momento que se entra no universo da recuperação, as coisas começam a caminhar. O aplicativo é um grande conector de 1.200 endereços de entidades no Estado de São Paulo." Além da localização, o app informa dias e horários das reuniões.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/584691/sem-tempo-saiba-como-usar-as-respostas-automaticas-do-whatsapp" target="_blank">Sem tempo? Saiba como usar as respostas automáticas do WhatsApp</a></p>
<p>Alcoólicos Anônimos (AA), Narcóticos Anônimos (NA), Amor-Exigente e Associação Antialcoólica do Estado de São Paulo estão entre as entidades indicadas pelo aplicativo. Não é preciso pagar para usar a ferramenta. Basta fazer o download. "Paguei, do meu bolso, R$ 10 mil para um amigo desenvolver o aplicativo. Estava para morrer na rua, sem nada, e, hoje, tenho uma vida boa. Recebi tudo isso de graça, então, não tem motivo para cobrar." As informações são do jornal <strong>O Estado de S. Paulo e Estadão Conteúdo. </strong></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Estadao Conteudo</dc:creator>
                    <pubDate>Mon, 30 Apr 2018 10:55:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae71fec66f96.jpg?1525096512" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Adeus, Flickr! Plataforma é comprada pela concorrente SmugMug]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584710/adeus-flickr-plataforma-e-comprada-pela-concorrente-smugmug?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584710/adeus-flickr-plataforma-e-comprada-pela-concorrente-smugmug?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Usuários cadastrados precisam decidir se fazem o backup, ou se transferem o conteúdo]]></description>
                                            <content:encoded><![CDATA[<p>A plataforma de armazenamentos de imagens Flickr anunciou na última semana que o serviço foi adquirido pela SmugMug, site de hospedagem e compartilhamento de imagens pagas de fotógrafos profissionais.</p>

<p>Em comunicado, o Flickr disse que as contas não sofrerão mudanças imediatas. Mas seus mais de 75 mil usuários precisam decidir, até o dia 25 de maio, se querem fazer um backup das imagens, ou transferir tudo para o outro serviço (que, lembrando, é pago).</p>
<p>Já as contas do SmugMug seguem inalteradas. Segundo o CanalTech, a empresa disse que o resultado desta união será a comunidade fotográfica mais influente do mundo.</p>
<p>Leia também:  <a href="https://www.noticiasaominuto.com.br/tech/584691/sem-tempo-saiba-como-usar-as-respostas-automaticas-do-whatsapp" target="_blank">Sem tempo? Saiba como usar as respostas automáticas do WhatsApp</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 30 Apr 2018 09:04:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae706a26c8ee.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Órbita da Terra já acumula 7,5 mil toneladas de sucata]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584415/orbita-da-terra-ja-acumula-7-5-mil-toneladas-de-sucata?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584415/orbita-da-terra-ja-acumula-7-5-mil-toneladas-de-sucata?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Em 60 anos de atividade espacial, mais de 5 mil lançamentos de foguetes fizeram com que a órbita da ]]></description>
                                            <content:encoded><![CDATA[<p>No início de abril, a estação espacial chinesa Tiangong-1 - que pesava 8,5 toneladas e estava fora de controle e inoperante desde 2006 - caiu no Oceano Pacífico, chamando a atenção do mundo para a questão da sucata espacial. Mas, segundo estudos feitos pela Agência Espacial Europeia (ESA), o problema é bem mais grave do que a queda de um módulo em pane: a quantidade de lixo aumentou consideravelmente nos últimos anos, deixando o espaço orbital da Terra cada vez mais próximo do limite de saturação.</p>

<p>Em 60 anos de atividade espacial, mais de 5 mil lançamentos de foguetes fizeram com que a órbita da Terra ficasse repleta de dejetos. A ESA estima que satélites inoperantes, partes de foguetes, peças de espaçonaves e pedaços de objetos relacionados a missões espaciais já somam 7,5 mil toneladas de lixo orbital.</p>
<p>+<a href="https://www.noticiasaominuto.com.br/tech/584449/facebook-remova-efeitos-especiais-em-termos-como-parabens-e-abraco" target="_blank"> Facebook: remova efeitos especiais em termos como 'parabéns' e 'abraço'</a></p>
<p>Esses detritos viajam em torno da Terra em velocidades alucinantes, que podem passar dos 28 mil quilômetros por hora. Nessas condições, a colisão de um pequeno parafuso com um satélite pode ter o efeito de um tiro de canhão.</p>
<p>"Se reduzirmos os lançamentos espaciais a zero hoje mesmo, o número de objetos vai continuar aumentando da mesma forma. Isso porque cada colisão espalha um grande número de detritos, que continuam viajando no espaço em grande velocidade, produzindo novas colisões", disse ao Estado o diretor do Escritório de Detritos Espaciais da ESA, Holger Krag.</p>
<p>De acordo com Krag, esse efeito cascata, que tende a aumentar exponencialmente os riscos de novas colisões, praticamente inviabilizando o uso da órbita terrestre para atividades espaciais, foi previsto em 1978 por um consultor da Nasa, Donald Kessler. Quatro décadas depois, a chamada "síndrome de Kessler" já é uma realidade.</p>
<p>"Há cinco anos, concluímos que a síndrome de Kessler já acontece em algumas regiões do espaço e então corremos para implementar nosso programa de redução do lixo espacial. Estamos desenvolvendo tecnologias de remoção ativa dos detritos. Se conseguirmos recursos, o programa entrará em ação em 2023", afirmou Krag.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/584395/como-procurar-filmes-e-series-da-netflix-de-forma-mais-pratica" target="_blank">Como procurar filmes e séries da Netflix de forma mais prática</a></p>
<p>Ele conta que a prioridade é retirar do espaço os objetos grandes - que são a maior fonte de novos detritos - e os mais próximos à Terra, onde se concentra mais lixo. "Objetos menores também são perigosos, mas têm mais chance de cair na atmosfera, desintegrando-se."</p>
<p>Segundo Krag, o tempo entre duas colisões está ficando cada vez mais curto. "Hoje, acontece uma colisão a cada cinco anos, provocando milhares de fragmentos. Nesse ritmo, em poucas décadas a órbita baixa da Terra ficará impraticável."</p>
<p>Segundo Krag, em 2009 foi registrada a primeira colisão entre dois satélites de comunicação: um deles, russo, desativado, e o outro, americano, em operação. "Só nesse episódio foram lançados mais de 2 mil fragmentos de lixo. Por isso é tão urgente rastrear e eliminar esses objetos maiores."</p>
<p>Já foram rastreados até agora mais de 23 mil detritos com mais de 10 centímetros na órbita da Terra. Outros 750 mil fragmentos têm entre 1 e 10 centímetros. Estima-se que haja ainda 166 milhões de dejetos com menos de 1 centímetro, que não podem ser rastreados. As informações são do jornal <strong>O Estado de S. Paulo e Estadão Conteúdo.</strong></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Estadao Conteudo</dc:creator>
                    <pubDate>Mon, 30 Apr 2018 05:50:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_562e2f2e218f7.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Facebook: remova efeitos especiais em termos como 'parabéns' e 'abraço']]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584449/facebook-remova-efeitos-especiais-em-termos-como-parabens-e-abraco?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584449/facebook-remova-efeitos-especiais-em-termos-como-parabens-e-abraco?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Recurso pode ser desativado de forma bem rápida e simples]]></description>
                                            <content:encoded><![CDATA[<p>Sabe quando você escreve uma mensagem de aniversário no mural do Facebook de algum amigo e a palavra <span class="news_highlight" style="background-color: #fff1aa;">'Parabéns'</span> surge em negrito e na cor laranja? Este recurso especial acompanha palavras-chaves como <span class="news_highlight" style="background-color: #fff1aa;">'um abraço'</span> ou<span class="news_highlight" style="background-color: #fff1aa;"> 'hahaha'</span>. Mas, caso não goste do efeito, saiba que ele pode ser removido de forma bem fácil.</p>

<p>De acordo com o 'TechTudo', assim que o Facebook criar o efeito especial de forma automática em algum post seu, clique nos três pontinhos localizados na parte superior da publicação e selecione a opção em <span class="news_bold">Remover efeitos de texto</span>.</p>
<p>Caso o efeito tenha surgido em um comentário seu na rede social, pressione a tela do celular em cima da palavra em destaque. Em seguida, toque na opção <span class="news_bold">Remover efeitos de texto</span>. </p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/584395/como-procurar-filmes-e-series-da-netflix-de-forma-mais-pratica" target="_blank">Como procurar filmes e séries da Netflix de forma mais prática</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Mon, 30 Apr 2018 05:09:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ada10967c759.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Apple vai parar de vender routers sem fios]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584609/apple-vai-parar-de-vender-routers-sem-fios?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584609/apple-vai-parar-de-vender-routers-sem-fios?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Há dois anos que a decisão era esperada]]></description>
                                            <content:encoded><![CDATA[<p>A Apple confirmou que abandonará definitivamente o negócio dos routers sem fios. “Estamos descontinuando os produtos Apple AirPort”, anunciou a empresa, adiantando que o restante stock será colocado à venda através do seu site online, lojas físicas e parceiros autorizados.</p>

<p>Como nota o 9to5mac, há muito que esta decisão era esperada. Afinal foi em 2016 que a empresa tecnológica de Cupertino desfez a equipe responsável por esta linha de produto. Além disso, foi em janeiro deste ano que a Apple começou a vender routers de outras fabricantes nas suas próprias lojas.</p>
<p>De notar que o fato de a Apple deixar de vender routers AirPort não signifique que estes produtos fiquem abandonados, sendo que a Apple continuará a apoiá-los durante os próximos anos.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 22:04:51 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae2d1318026c.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Golpe do Bolsa Família no WhatsApp faz 600 mil vítimas]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/583164/golpe-do-bolsa-familia-no-whatsapp-faz-600-mil-vitimas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/583164/golpe-do-bolsa-familia-no-whatsapp-faz-600-mil-vitimas?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Beneficiários do programa social são fisgados por falsa promessa de bônus]]></description>
                                            <content:encoded><![CDATA[<p>Uma mensagem que oferece um adicional de R$ 954 aos beneficiários do Bolsa Família é a porte de entrada para um golpe no Whatsapp que já fez 600 mil vítimas. O dfndr lab, braço de pesquisas de cibercrime da PSafe, que atua no mercado de antivírus para Android, alertou os beneficiários do programa do governo para não se deixarem seduzir por falsas promessas.</p>

<p>"Você possui o cartão bolsa família?", "Você recebe todo mês?" e "Você conhece amigos ou parentes que recebe?" são as perguntas colocadas para quem clica no link. </p>
<p><a href="https://www.noticiasaominuto.com.br/tech/583120/ministerio-publico-processa-microsoft-por-coleta-de-dados-no-windows-10" target="_blank">+ Ministério Público processa Microsoft por coleta de dados no Windows 10</a></p>
<p>Segundo informações do G1, o golpe funciona da seguinte forma: a falsa mensagem leva os usuários a uma página que os obriga a compartilhar o link malicioso com os seus contatos no aplicativo. Em seguida, o site sugere a instalação de apps indesejados, que podem deixar os smartphones vulneráveis. O objetivo do golpe é que a vítima encaminhe o endereço eletrônico malicioso para dez amigos, na ilusão de que vão receber o benefício.</p>
<p>A notícia de que a equipe econômica do Governo Federal estuda um aumento no valor do benefício colocou o tema em evidência. Em apenas 24 horas, 600 mil pessoas acessaram o link suspeito, que acabou sendo bloqueado pelos filtros de segurança da empresa PSafe.</p>
<p>Tais instalações de aplicativos vêm sendo recomendadas de forma recorrente para os usuários de Android, já que os desenvolvedores de apps costumam pagar quem recomenda a instalação dos seus "produtos", inclusive por aqueles de instalação gratuita. A recomendação é ignorar os links suspeitos, nunca acessar o site indicado nem encaminhar o link.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 17:59:26 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae11244964e6.jpg?1524699857" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[NASA finaliza desenvolvimento do único veículo lunar]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584537/nasa-finaliza-desenvolvimento-do-unico-veiculo-lunar?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584537/nasa-finaliza-desenvolvimento-do-unico-veiculo-lunar?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Cientistas enviaram uma carta à NASA onde exprimem a surpresa pela decisão tomada]]></description>
                                            <content:encoded><![CDATA[<p>A NASA anunciou na sexta-feira (27) ter finalizado o seu único programa de desenvolvimento de um veículo lunar, apesar das declarações em finais do ano passado do Presidente norte-americano, Donald Trump, de que queria voltar a enviar astronautas à Lua.</p>

<p>O anúncio, feito no site da agência espacial, pegou de surpresa os próprios cientistas envolvidos no programa, denominado 'Resource Prospector' (RP), que deveria conduzir à construção de um veículo robotizado destinado a explorar as regiões polares da Lua.</p>
<p>Segundo a France Press, os cientistas enviaram uma carta à NASA onde exprimem a surpresa pela decisão tomada.</p>
<p>"Tomamos agora conhecimento de que o RP foi suspenso a 23 de abril de 2018 e que a missão terá fim até final de maio", referem os membros do 'Lunar Exploration Analysis Group' (LEAG) no correio eletrônico enviado a Jim Bridenstine, que lidera a agência, e publicado no site 'NASAWatch.com'.</p>
<p>Os cientistas sublinham a "incredulidade e consternação" com que a notícia foi recebida na sua comunidade.</p>
<p>O robot lunar, cuja construção foi iniciada há cerca de dez anos, deveria ser o único do mundo capaz de explorar as regiões polares da Lua.</p>
<p>Seria ainda o primeiro módulo lunar norte-americano depois do Apollo 17, de 1972, e o primeiro veículo autônomo dos Estados Unidos sobre a Lua, com lançamento previsto para 2022.</p>
<p>A NASA indicou, em comunicado, que certos instrumentos do programa RP serão utilizados em futuros projetos da agência espacial, até porque diz ter prevista uma série de "missões robóticas graduais na superfície lunar", sem fazer referência específica à anulação do programa RP.</p>
<p>A agência procura "evoluir progressivamente no sentido de veículos de aterrissagem maiores, capazes eventualmente de ser habitados", indica apenas o comunicado.</p>
<p>Jim Bridenstine, confirmado esta semana na liderança da NASA, assegurou no Twitter que está empenhado na exploração lunar.</p>
<p>O Presidente dos Estados Unidos confirmou em dezembro do ano passado a vontade dos Estados Unidos de voltar a enviar astronautas para a Lua pela primeira vez desde 1972, a fim de preparar uma missão habitada em direção a Marte.</p>
<p>"Desta vez, não se trata apenas de colocar a nossa bandeira e de deixar as nossas pegadas. Estabeleceremos uma base para uma missão a Marte e talvez um dia mais além", declarou Trump numa cerimônia na Casa Branca. Com informações da Agência Lusa.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Lusa</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 17:48:14 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/21145709.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Nokia prepara regresso de mais um clássico]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584509/nokia-prepara-regresso-de-mais-um-classico?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584509/nokia-prepara-regresso-de-mais-um-classico?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A linha N da marca finlandesa pode ter direito a uma nova versão com Android]]></description>
                                            <content:encoded><![CDATA[<p>A Nokia tem tido um fluxo estável no que diz respeito ao lançamento de novos smartphones. A empresa acabou lançando novas versões de dispositivos móveis que foram um sucesso do seu portfólio no passado. Desta vez, parece que - depois do 3310 e do 8810 - teremos direito a mais um.</p>

<p>Como nota o <a href="https://www.mysmartprice.com/gear/2018/04/25/nokia-n-series-27-april-announcement/" target="_blank">MySmartPrice</a>, a Nokia poderá lançar uma nova versão do popular Nokia N9, um dispositivo lançado em 2005 com o sistema operativo Symbian que havia de ‘sucumbir’ perante o iOS do iPhone e o Android da Google. Apesar disso, o celular deu início aos que muitos consideram ser o mercado dos smartphones e agora a empresa estaria prestes a relançar este modelo.</p>
<p>É esta a ideia que fica depois de ver a publicação da Nokia na sua página na rede social chinesa Weibo, que aponta para novidades no período que vai desde o dia 27 de abril até ao dia 2 de maio. Teremos de esperar por confirmações da própria Nokia ou da HMD Global, que detém os direitos de fábrica da marca.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 15:21:36 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5664858c56222.jpg?1525026156" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Em esforço global, cientistas criam mapa genético da depressão]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584244/em-esforco-global-cientistas-criam-mapa-genetico-da-depressao?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584244/em-esforco-global-cientistas-criam-mapa-genetico-da-depressao?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Resultado identificou 44 genes relacionados a formas severas da doença]]></description>
                                            <content:encoded><![CDATA[<p>Embora a depressão afete 14% da população mundial, apenas metade dos pacientes responde bem aos tratamentos a que são submetidos. Com o objetivo de tratar a doença de forma mais eficaz, duzentos cientistas de mais de 161 instituições em todo o mundo juntaram esforços para criar um mapa genético da depressão. O resultado, publicado na 'Nature Genetics' mostra que pesquisadores conseguiram identificar 44 genes relacionados a formas severas da doença.</p>

<p>O estudo faz parte do "Psychiatric Genomics Consortium" e foi coordenado por três instituições: Kings College London (Reino Unido), da Universidade da Carolina do Norte (EUA) e da Universidade de Queensland (Austrália). O levantamento considerou dados de 135 mil pacientes depressivos e 344 mil pessoas que não apresentam quadro da doença.</p>
<p>De acordo com o G1, a pesquisa tem como base estudos anteriores que garantem que hereditariedade tem um peso importante na ocorrência de quadros depressivos. Dos 44 genes mapeados, 30 foram descritos de forma inédita nesta iniciativa. Agora, a descoberta abre portas para o surgimento de terapias e tratamentos mais específicos para a condição.</p>
<p>Leia também:<a href="https://www.noticiasaominuto.com.br/tech/584172/descubra-tudo-o-que-o-whatsapp-sabe-sobre-vocehttps://www.noticiasaominuto.com.br/tech/584172/descubra-tudo-o-que-o-whatsapp-sabe-sobre-voce" target="_blank"> Descubra tudo o que o WhatsApp sabe sobre você</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 13:42:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5a76da9fc653c.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Telescópio russo mapeia lixo espacial em MG]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584421/telescopio-russo-mapeia-lixo-espacial-em-mg?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584421/telescopio-russo-mapeia-lixo-espacial-em-mg?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Brasil passou a fazer parte da "faxina espacial" há dois anos]]></description>
                                            <content:encoded><![CDATA[<p>O Brasil começou a participar concretamente do esforço internacional de "faxina espacial" há exatos dois anos, quando o Laboratório Nacional de Astrofísica (LNA) assinou com a Agência Espacial Russa (Roscosmos) um acordo para mapear os detritos espaciais. Há um ano, foi inaugurado em Brazópolis, no sul de Minas Gerais, um telescópio russo-brasileiro exclusivamente dedicado ao monitoramento de lixo espacial.</p>

<p>De acordo com o diretor do LNA, Bruno Castilho, o Brasil entrou na iniciativa por causa de sua localização geográfica. Para mapear o lixo espacial com precisão, os russos precisavam de um parceiro no Hemisfério Sul. "A Roscosmos tem um telescópio dedicado ao rastreamento na Rússia, que funciona em conjunto com o que operamos aqui. Com um telescópio em cada hemisfério, conseguimos localizar os detritos com mais precisão, porque sua posição é marcada pelos dois lados da Terra", explicou Castilho.</p>
<p>+ <a href="https://www.noticiasaominuto.com.br/tech/584415/orbita-da-terra-ja-acumula-7-5-mil-toneladas-de-sucata" target="_blank">Órbita da Terra já acumula 7,5 mil toneladas de sucata</a></p>
<p>Quando as coordenadas do objeto detectado são obtidas, os dados são enviados para a Agência Espacial Europeia (ESA) e para a Nasa, a agência espacial americana, para serem registrados em um catálogo internacional. "Mesmo que as iniciativas de remoção ativa do lixo espacial ainda não tenham começado de fato, essas informações já são muito úteis. Quando um satélite novo é enviado, ele é programado para evitar aquela rota com detritos", disse.</p>
<p>O telescópio do LNA, que fica no Observatório do Pico dos Dias, a mais de 1,8 mil metros de altitude, funciona diariamente, em noites de céu aberto. De acordo com o cientista, ele tem mapeado de 500 a 800 detritos espaciais por noite.</p>
<p>"O pessoal da Rússia produz os dados principais e define para onde apontar o telescópio do Hemisfério Norte. Eles então enviam os dados para o Brasil e nossos técnicos fazem as observações. Um software caracteriza exatamente o que é o detrito, envia os dados à Rússia e lá eles fazem o processamento final."</p>
<p><strong>Menos detrito, mais limpeza</strong></p>
<p>Segundo Castilho, o governo da Rússia financiou toda a construção e a instalação do telescópio e contratou os funcionários brasileiros que atuam no projeto. "A operação envolve seis cientistas e técnicos brasileiros contratados pela Roscosmos. Não sabemos o valor investido no equipamento, mas estimamos em R$ 10 milhões", disse.</p>
<p>O LNA emprestou o terreno para a instalação do instrumento e, como contrapartida, os cientistas brasileiros podem utilizar todas as imagens produzidas por ele em estudos astronômicos. "Esse instrumento tem uma resolução mais baixa que os telescópios astronômicos, mas possui um campo de visão maior. Quando procuramos uma estrela variável, ou uma região onde há uma explosão de supernova, por exemplo, ele é muito eficiente", explicou.</p>
<p>Segundo o tecnologista Ademir Xavier Júnior, da Agência Espacial Brasileira (AEB), o Brasil tem atualmente uma dúzia de objetos em órbita, o que nos dá o status de "país lançador". Com isso, a AEB tem a responsabilidade de registrar todos os objetos espaciais do País, para que seja possível contabilizar possíveis impactos ambientais. O impacto do lixo espacial brasileiro, porém, é pequeno. A proporção de objetos lançados equivale a 0,95% do total dos que foram registrados pelos Estados Unidos e 0,76% dos registrados pela Rússia.</p>
<p>"Não é o caso de se dizer que inexiste impacto do lixo do Brasil, mas, certamente, as chances maiores de danos estão do lado das nações que mais lançam. É preciso lembrar que não são apenas satélites em órbita que contam, mas também resíduos de lançamento que não têm mais função uma vez finalizada a inserção em órbita", disse Xavier ao Estado.</p>
<p>De acordo com Xavier, o desenvolvimento de tecnologias de "limpeza orbital" não terá sucesso se for dirigido apenas por um país. "Existem questões de jurisprudência internacional envolvidas, além da necessidade de desenvolver técnicas que exigem orçamento proporcional ao tamanho do problema. As colisões sucessivas entre objetos em órbita e o aumento esperado de lançamentos tornarão o problema do lixo espacial uma questão grave que exigirá a participação de todos os países lançadores", disse.</p>
<p>O tecnologista afirma que, além da operação do telescópio russo em Minas Gerais, o Brasil tem contribuído com a "limpeza espacial" com a publicação de diversos estudos sobre mitigação do problema. Ele diz também que os dados internacionais de monitoramento desses objetos já são utilizados no planejamento das missões espaciais brasileiras para evitar os riscos de impacto. As informações são do jornal <strong>O Estado de S. Paulo e Estadão Conteúdo. </strong></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Estadao Conteudo</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 12:18:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5abcaef3402d8.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Samsung enfrenta novo processo na Justiça norte-americana]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584410/samsung-enfrenta-novo-processo-na-justica-norte-americana?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584410/samsung-enfrenta-novo-processo-na-justica-norte-americana?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Fabricante vai responder por supostas violações de patentes tecnológicas nos EUA e na Coreia do Sul]]></description>
                                            <content:encoded><![CDATA[<p>Um novo processo contra a Samsung foi aberto na Justiça dos Estados Unidos pela empresa de segurança de dados PACid Technologies, no Texas. A fabricante sul-coreana vai responder por supostas violações de patentes tecnológicas em recursos de impressão digital, reconhecimento facial, leitura de íris e reconhecimento de usuários adjacentes.</p>

<p>De acordo com o 'TecMundo', a Samsung teria copiado três patentes de segurança da PACid: duas nos EUA e uma na Coreia do Sul. A empresa quer que a Samsung arque com os prejuízos da violação, devolvendo valores referentes aos lucros pelos produtos.</p>
<p>A PACid alega que os recursos fazem parte dos aparelhos da linha Galaxy - do S6 até o S8. E, supostamente, a Samsung saiba da violação desde janeiro do ano passado.</p>
<p>Leia também:<a href="https://www.noticiasaominuto.com.br/tech/584395/como-procurar-filmes-e-series-da-netflix-de-forma-mais-pratica" target="_blank"> Como procurar filmes e séries da Netflix de forma mais prática</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 08:21:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_59d36e4e264db.jpg?1525000881" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Como procurar filmes e séries da Netflix de forma mais prática]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584395/como-procurar-filmes-e-series-da-netflix-de-forma-mais-pratica?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584395/como-procurar-filmes-e-series-da-netflix-de-forma-mais-pratica?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Superdica para quem quer sair da "bolha" do conteúdo indicado pelo serviço streaming]]></description>
                                            <content:encoded><![CDATA[<p>É possível ter acesso a diversos títulos do catálogo da Netflix apenas "zapeando" o serviço streaming. Enquanto uns são fiéis a categoria do "sugestões para você", outros gostam de escolher filmes e séries de forma mais espotânea.</p>

<p>Se quiser variar a forma como busca seu conteúdo favorito, saiba que a Netflix oferece quatro critérios de busca (mas que nem todos conhecem): sugestões para você, ordem alfabética crescente, ordem alfabética decrescente ou ano de lançamento.</p>
<p>Para não ficar na "bolha" do conteúdo indicado para você, procurar títulos por meio da ordem alfabética pode ser interessante e oferecer todo um novo olhar sobre a plataforma. Segundo o TecMundo, é possível selecionar este critério dentro do gênero que quiser assistir (como terror ou ficção científica). Depois, selecione os ícones na direita com tracinhos, ou pontinhos.</p>
<p>Leia também:<a href="https://www.noticiasaominuto.com.br/tech/584244/em-esforco-global-cientistas-criam-mapa-genetico-da-depressao" target="_blank"> Em esforço global, cientistas criam mapa genético da depressão</a></p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 07:10:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae5998c2ea6e.jpg?1524996638" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Cientistas criam luva capaz de controlar níveis de sono]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584390/cientistas-criam-luva-capaz-de-controlar-niveis-de-sono?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584390/cientistas-criam-luva-capaz-de-controlar-niveis-de-sono?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Objetivo dos cientistas era estudar a fase "criativa" do sono, conhecida como hypnophagia]]></description>
                                            <content:encoded><![CDATA[<p>Pesquisadores do Instituto de Tecnologia de Massachusetts criaram uma luva capaz de controlar os níveis de sono. O objetivo dos cientistas é estudar a fase conhecida como hypnophagia, que é repleta de criatividade, mas que cai no esquecimento a partir do momento que o sono profundo chega.</p>

<p>De acordo com o TecMundo, a luva consegue detectar o início desta fase por meio do relaxamento muscular. Quando os voluntários da experiência entrava no período de hypnophagia, eles passavam a ouvir áudios com orientações programadas - e acordavam antes do sono profundo. Ao retornar ao estado consciente, estas pessoas conseguiram desenvolver ideias de grande teor criativo sobre as palavras que ouviram durante o teste.</p>
<p>Lenda da inovação, Thomas Edison fez um experimento semelhante com uma esfera de ferro. Segundo o cientista, esta fase do sono estaria relacionada ao alcance da genialidade, já que o cérebro conseguiria desenvolver raciocínios mais avançados do que no estado consciente.</p>
<p>Os resultados foram promissores. Agora, é preciso aguardar para ver como estes dados podem ser explorados por profissionais da neurociência.</p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/584244/em-esforco-global-cientistas-criam-mapa-genetico-da-depressao" target="_blank">Em esforço global, cientistas criam mapa genético da depressão</a></p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sun, 29 Apr 2018 07:03:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae59589a8348.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Tecnologia de seleção genética traz melhoras a zebuínos no Brasil]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584349/tecnologia-de-selecao-genetica-traz-melhoras-a-zebuinos-no-brasil?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584349/tecnologia-de-selecao-genetica-traz-melhoras-a-zebuinos-no-brasil?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A primeira etapa do processo vai contar com apoio do governo federal]]></description>
                                            <content:encoded><![CDATA[<p>Um acordo entre a Associação Brasileira dos Criadores de Zebu e a Empresa Brasileira de Pesquisa Agropecuária para desenvolver as avaliações genéticas vai contar com apoio federal</p>

<p>A Associação Brasileira dos Criadores de Zebu (ABCZ) e a Empresa Brasileira de Pesquisa Agropecuária (Embrapa) assinaram, esta semana, um acordo de cooperação técnica para condução conjunta das avaliações genéticas genômicas nacionais dos zebuínos. O anúncio representa uma perspectiva para o melhoramento genético das raças, predominantes na pecuária brasileira.</p>
<p><span class="news_bold">Leia também</span>: <a href="https://www.noticiasaominuto.com.br/tech/584294/saiba-testar-novo-gmail-com-mais-recursos-de-privacidade-e-seguranca" target="_blank">Saiba testar novo Gmail, com mais recursos de privacidade e segurança</a></p>
<p>A primeira etapa do processo vai contar com apoio do governo federal: a genotipagem de milhares de animais que formarão a população de referência. A partir dessa população de referência será possível produzir DEPs genômicas (uma ferramenta tecnológica de seleção genômica) que beneficiarão direta ou indiretamente todos os criadores.</p>
<p>O grupo acredita que esta ação será capaz de mobilizar os criadores a investirem na genotipagem, uma vez que os benefícios só serão efetivos se os novos animais continuarem a ser genotipados e fenotipados. As amostras biológicas (pelos da vassoura da cauda) já começaram a ser colhidas e serão enviadas aos laboratórios para extração e leitura de DNA. A meta é incorporar as informações genômicas na avaliação genética nacional das raças zebuínas, que será conduzida pelas duas entidades, ainda este ano de 2018.</p>
<p>Henrique Ventura, Superintendente Adjunto de Melhoramento Genético da ABCZ, destaca que o impacto da parceria será significativo. “Os selecionadores e compradores de genética poderão tomar suas decisões lastreadas em avaliações genéticas produzidas por duas entidades representativas da pecuária nacional e que têm como missão contribuir para o aumento sustentável da produção de alimentos no Brasil e no mundo.”</p>
<p>(Portal Brasil)</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 28 Apr 2018 19:51:51 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_55956b08c5147.jpg?1524955884" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Após 20 anos, Apple anuncia término de linha de produtos]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584320/apos-20-anos-apple-anuncia-termino-de-linha-de-produtos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584320/apos-20-anos-apple-anuncia-termino-de-linha-de-produtos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Companhia revelou que não trabalhará mais com roteadores Wi-Fi]]></description>
                                            <content:encoded><![CDATA[<p>No mercado de roteadores de Wi-Fi desde 1999, a Apple anunciou o fim da linha dos produtos AirPort e Time Capsule. Os motivos não foram divulgados.</p>

<p>Em entrevista ao portal Engadget, um porta-voz da companhia disse que a venda dos produtos permanecerá até que se esgotem os estoques. Garantiu também o prosseguimento dos serviços de manutenção e atualização.</p>
<p><span class="news_bold">Leia também</span>: <a href="https://www.noticiasaominuto.com.br/tech/584294/saiba-testar-novo-gmail-com-mais-recursos-de-privacidade-e-seguranca" target="_blank">Saiba testar novo Gmail, com mais recursos de privacidade e segurança</a></p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 28 Apr 2018 17:45:40 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ad48510a7bcf.jpg?1524948099" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Saiba testar novo Gmail, com mais recursos de privacidade e segurança]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584294/saiba-testar-novo-gmail-com-mais-recursos-de-privacidade-e-seguranca?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584294/saiba-testar-novo-gmail-com-mais-recursos-de-privacidade-e-seguranca?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[A nova versão é a maior atualização do aplicativo nos últimos anos]]></description>
                                            <content:encoded><![CDATA[<p>A Google anunciou esta semana mudanças na sua ferramenta de e-mail, o Gmail. A companhia criou uma nova funcionalidade denominada “modo confidencial do Gmail”. A nova versão é a maior atualização do aplicativo nos últimos anos e traz recursos adicionais que permitem maior controle sobre as mensagens enviadas.</p>

<p>Segundo o site especializado Statista, o Gmail é o segundo aplicativo de correio eletrônico mais popular do mundo, ficando atrás apenas do utilizado no Iphone da Apple. A medida é uma iniciativa do conglomerado em um momento em que a capacidade das plataformas digitais de proteger os dados dos usuários é questionada, especialmente em razão do escândalo envolvendo o Facebook e a empresa de marketing digital britânica Cambridge Analytica.</p>
<p> No modo confidencial do Gmail, o usuário pode, por exemplo, criar data de validade para uma mensagem enviada, que é deletada no prazo determinado. Outro recurso possibilita que o detentor de uma conta apague uma mensagem já enviada. A possibilidade de apagar conteúdos enviados já existe em aplicativos como Whatsapp. Já o “prazo de validade” é um dos recursos de outro mensageiro, o Telegram.</p>
<p>O novo Gmail permite novas formas de autenticação. Entre elas está a necessidade de um código adicional que o remetente deve disponibilizar ao destinatário para que ele possa abrir a mensagem e ter acesso ao conteúdo.</p>
<p>O detentor de conta pode controlar também ações do destinatário com o e-mail. Há a possibilidade de proibir, por exemplo, que a pessoa encaminhe, imprima, copie ou baixe a mensagem. “Isso ajuda a reduzir o risco de informações confidenciais serem compartilhadas com as pessoas erradas”, explica o vice-presidente de gestão de produtos, David Thacker.</p>
<p>O “novo Gmail”, contudo, ainda não está sendo oferecido pela Google aos usuários que já dispõe do aplicativo. Para testar, ou migrar definitivamente para a nova versão, o detentor de uma conta precisa alterar as configurações, em procedimento bastante simples.</p>
<p>No canto superior direito, há um botão chamado “configurações” (ou “settings” para quem usa a versão em inglês”). Ao apertar, abrirá um menu em que há a opção “testar novo Gmail”. Clicando nesta alternativa, o usuário é direcionado para o aplicativo atualizado, podendo escolher entre os modos padrão, confortável ou compacto. Com informações da Agência Brasil. </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Agência Brasil</dc:creator>
                    <pubDate>Sat, 28 Apr 2018 16:15:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae4c818b2507.jpg?1524942917" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Conheça Looke: o 'Netflix brasileiro' que permite o aluguel de filmes]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584213/conheca-looke-o-netflix-brasileiro-que-permite-o-aluguel-de-filmes?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584213/conheca-looke-o-netflix-brasileiro-que-permite-o-aluguel-de-filmes?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Cada aluguel dura 48 horas a partir do primeiro "play"]]></description>
                                            <content:encoded><![CDATA[<p>O Looke é um serviço brasileiro de streaming de filmes e séries. Se acha que esta proposta é bastante parecida ao da rival Netflix, a plataforma apresenta alguns diferenciais, como conteúdo "sob demanda" online. Ou seja, além do plano mensal, clientes podem optar por alugar determinado título do catálogo.</p>

<p>Há três opções de serviços, confira:</p>
<p><span class="news_bold">Vídeo Club</span></p>
<p>A assinatura cobrada mensalmente te dá o acesso ilimitado aos filmes com selo Vídeo Club.</p>
<p><span class="news_italic">Valor: R$16,90 (1 tela) | R$18,90 (3 telas)| R$25,90 (5 telas e 1 locação por mês)</span></p>
<p> </p>
<p><span class="news_bold">Aluguel Digital:</span></p>
<p>O usuário paga por cada filme que alugar. Cada aluguel dura 48 horas a partir do primeiro "play".</p>
<p><span class="news_italic">Valor: a partir de R$ 1,89</span></p>
<p><span class="news_bold">Compra digital:</span></p>
<p>O valor é cobrado por cada filme comprado e o cliente tem acesso ao título por tempo ilimitado.</p>
<p><span class="news_italic">Valor: a partir de R$ 14,90</span></p>
<p>Além da versão web, o Looke também está disponível em aplicativo para os sistemas Android e iPhone (iOS). Ficou interessado? As assinaturas podem ser feitas no <a href="https://www.looke.com.br/" target="_blank">site da plataforma</a>.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 28 Apr 2018 11:21:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ad6533a175f1.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Imagens do suposto novo iPhone SE circulam na internet]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/583873/imagens-do-suposto-novo-iphone-se-circulam-na-internet?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/583873/imagens-do-suposto-novo-iphone-se-circulam-na-internet?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Rumores sobre o possível modelo estão ganhando cada vez mais força]]></description>
                                            <content:encoded><![CDATA[<p>Fãs do design clássico do iPhone SE certamente gostariam de ver uma segunda versão do modelo da Apple. Pois bem, o site 9to5mac compartilhou algumas imagens deste possível smartphone.</p>

<p>Apesar das imagens serem promissoras, há certas particularidades que fazem com que este rumor perca a força. Entre elas, a presença de uma entrada de áudio convencional, algo que a Apple parou de usar desde o iPhone 7. </p>
<p>+<a href="https://www.noticiasaominuto.com.br/tech/583772/gif-impressionante-revela-a-superficie-de-um-cometa-em-movimento" target="_blank"> GIF impressionante revela a superfície de um cometa em movimento</a></p>
<p>Em contrapartida, esta versão do iPhone SE 2 parece incluir uma face traseira com vidro. Isso sim é algo que a Apple tem incluído nos mais recentes iPhone 8, iPhone 8 Plus e o iPhone X.</p>
<p>Veja as imagens na galeria acima.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 28 Apr 2018 08:07:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae1dd2282fd2.jpg" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Descubra tudo o que o WhatsApp sabe sobre você]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584172/descubra-tudo-o-que-o-whatsapp-sabe-sobre-voce?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584172/descubra-tudo-o-que-o-whatsapp-sabe-sobre-voce?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Por enquanto, recurso está disponível para versão Beta do aplicativo no sistema Android]]></description>
                                            <content:encoded><![CDATA[<p>A versão beta 2.18.128 do WhatsApp liberou um recurso de solicitação de dados da conta, que permite que os usuários saibam quais informações o aplicativo guarda. Por enquanto, a ferramenta está disponível apenas para o sistema Android, mas deve chegar em breve ao iOS.</p>

<p>Para descobrir e baixar estes dados, siga o passo a passo divulgado pelo 'Techtudo'.</p>
<p>1. Abra a versão testes do aplicativo e entre no menu principal (os três pontos verticais localizados no canto da tela). Depois, toque em <span class="news_bold">Configurações</span>.</p>
<p>2. Selecione conta e, em seguida, <span class="news_bold">Solicitar dados da conta</span>.</p>
<p>3. Para receber seus dados, clique em <span class="news_bold">Solicitar Relatório</span>. O documento pode demorar até três dicas para ficar pronto.</p>
<p>4. O WhatsApp vai enviar um alerta no momento em que o relatório for concluído. Em seguida, toque em <span class="news_bold">Baixar Relatório</span>. Para concluir o download, toque em <span class="news_bold">Exportar Relatório</span>.</p>
<p>5. Por fim, clique em <span class="news_bold">Exportar</span> e escolha de que forma você quer que o arquivo seja enviado. Uma das opções é enviar o documento via Gmail, no formato '.zip'.</p>
<p>Leia também:<a href="https://www.noticiasaominuto.com.br/tech/584156/solo-de-marte-pode-ser-trazido-a-terra-por-agencias-espaciais" target="_blank"> Solo de Marte pode ser trazido à Terra por agências espaciais</a></p>
<p> </p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 28 Apr 2018 07:03:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ac0adc5dd2ab.jpg?1524909796" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Golpe do WhatsApp divulga promoção falsa de Dia das Mães]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/583969/golpe-do-whatsapp-divulga-promocao-falsa-de-dia-das-maes?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/583969/golpe-do-whatsapp-divulga-promocao-falsa-de-dia-das-maes?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Marca 'O Boticário' é usada como isca e emite comunicado]]></description>
                                            <content:encoded><![CDATA[<p>A marca de cosméticos O Boticário está servindo novamente de isca para golpes pelo WhatsApp. Desta vez, os cibercriminosos estão aproveitando o Dia das Mães para atrair as vítimas. A falsa promoção foi descoberta pela firma de segurança digital Arcon nesta quinta-feira (26)</p>

<p>"Ganhe um KIT Dia das Mães na O Boticário! Entre no link abaixo e siga o passo a passo para ganhar o seu", diz o texto do golpe.</p>
<p>O link é de um site malicioso. O usuário que clicar é levado a divulgar dados pessoais e instalar programas maliciosos no smartphone.</p>
<p>Em nota, O Boticário esclareceu "que não está realizando nenhuma promoção com sorteio de kits de Dia das Mães, conforme informação que circula pelas redes sociais".</p>
<p><span class="news_bold">Leia nota na íntegra </span></p>
<p>"O Boticário esclarece que não está realizando nenhuma promoção com sorteio de kits de Dia das Mães, conforme informação que circula pelas redes sociais.</p>
<p>O suposto sorteio, que direciona os interessados para uma página de internet, é falso, não corresponde com a realidade e ainda pode representar um risco a quem acessar links estranhos ou preencher possíveis formulários com dados pessoais.</p>
<p>A marca está apurando a origem desses boatos e caso algum consumidor se sinta lesado, os canais de comunicação de O Boticário estão abertos para eventuais dúvidas e esclarecimentos".</p>
<p> </p>
<p><img class="tinymceimage img-responsive" src="http://static.noticiasaominuto.com.br/stockimages/gallery/640/naom_5ae3517e8c5b1.jpg" border="0" alt="Notícias ao Minuto" width="441" height="231" /></p>
<p>Leia também: <a href="https://www.noticiasaominuto.com.br/tech/583929/edicao-vermelha-dos-iphones-8-e-plus-chega-ao-brasil-veja-os-precos" target="_blank">Edição vermelha dos iPhones 8 e Plus chega ao Brasil; veja os preços</a></p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Sat, 28 Apr 2018 06:21:00 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae3538686b16.jpg?1524847583" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Solo de Marte pode ser trazido à Terra por agências espaciais]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584156/solo-de-marte-pode-ser-trazido-a-terra-por-agencias-espaciais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584156/solo-de-marte-pode-ser-trazido-a-terra-por-agencias-espaciais?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[As agências espaciais dos Estados Unidos, NASA, e da Europa, ESA, assinaram declaração de intenção]]></description>
                                            <content:encoded><![CDATA[<p>As agências espaciais dos Estados Unidos, NASA, e da Europa, ESA, querem trazer amostras do solo de Marte à Terra. As duas assinaram, nesta quinta-feira (26), uma declaração de intenção na qual se comprometem a trabalhar em sondas, foguetes e robôs que possibilitem o feito.</p>

<p>Diretor de Exploração Humana e Robótica da ESA, David Parker declarou que, "para um cientista planetário", a chance de trazer de volta amostras de terra puras e cuidadosamente selecionadas do Planeta Vermelho é uma proposta de dar água na boca".</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/584065/iphones-podem-abrir-mao-do-touch-3d-para-ficarem-mais-baratos">+ iPhones podem abrir mão do touch 3D para ficarem mais baratos</a></p>
<p>Parker explicou ainda que as amostras podem ajudar a "reconstruir a história de Marte", bem como responder perguntas sobre o passado do planeta. O diretor também detalhou que a missão é complicada pelo fato de exigir pelo menos três viagens à Marte, além do lançamento de um foguete da superfície do Planeta Vermelho.</p>
<p>A primeira missão será da NASA, com o lançamento do Mars Rovers, em 2020, para coletar e armazenar 31 amostras de terra. A segunda parte será realizada pela sonda ExoMars, da ESA, em 2021. O objetivo é pegar mais solo, a dois metros de profundidade. Os itens coletados serão colocados em um contâiner do tamanho de uma bola de futebol. </p>
<p>Uma terceira sonda deve pousar em Marte para recolher as amostras anteriores, colocá-las em um foguete que chegue até a órbita de Marte. A quarta e última parte consiste em resgatar o contêiner, em um foguete, e trazê-lo de volta à Terra.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 27 Apr 2018 22:22:08 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae3cdb65cb95.jpg?1524878803" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[iPhones podem abrir mão do touch 3D para ficarem mais baratos]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584065/iphones-podem-abrir-mao-do-touch-3d-para-ficarem-mais-baratos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584065/iphones-podem-abrir-mao-do-touch-3d-para-ficarem-mais-baratos?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA[Modelos lançados em 2018 teriam display de 6.1 polegadas]]></description>
                                            <content:encoded><![CDATA[<p>Três meses depois de afirmar que a Apple lançará três novos iPhones ainda neste ano, com telas de 6.1 polegadas, o maior especilista da Apple no mundo, o analista da KGI Ming-Chi Kuo, detalhou funções dos novos aparelhos.</p>

<p>Segundo o site chinês Feng, citado pelo <a href="https://www.theverge.com/circuitbreaker/2018/4/27/17289946/apple-3d-touch-iphones-price">The Verge</a>, a ideia é que a empresa de Tim Cook comece a abrir mão do atual sistema de multi-toque para não pesar tanto no bolso. É que um novo display já deve aumentar o preço de cada aparelho em cerca de US$ 26 (cerca de R$ 100). Assim, alguns iPhones podem sair da caixa sem o 3D Touch.</p>
<p><a href="https://www.noticiasaominuto.com.br/cultura/583391/artista-cria-cenarios-do-cotidiano-em-miniatura">+ Novo RPG de 'Hora de Aventura' ganha trailer e data de lançamento</a></p>
<p>Segundo Kuo, a nova tela do iPhone usará a tecnologia chamada de Cover Glass Sensor (CGS) para permitir mais leveza e resistência a impacto. De acordo com o memorando publicado pelo Feng, o módulo de toque também "migrará" do painel para a superfície do vidro. O novo iPhone também teria um finíssimo sensor, mas os detalhes do recurso que oferece ainda são desconhecidos.</p>
<p>A remoção do 3D Touch não deve causar desagrado, já que a usabilidade do tipo de display não é consenso entre usuários. A expectativa é que os novos iPhones sejam apresentados em 2019.</p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 27 Apr 2018 17:32:06 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae389df6aa60.jpg?1524861572" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                            <item>
                    <title><![CDATA[Novo RPG de 'Hora de Aventura' ganha trailer e data de lançamento]]></title>
                                            <category>Tech</category>
                                        <link>https://www.noticiasaominuto.com.br/tech/584009/novo-rpg-de-hora-de-aventura-ganha-trailer-e-data-de-lancamento?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</link>
                    <guid isPermaLink="true">https://www.noticiasaominuto.com.br/tech/584009/novo-rpg-de-hora-de-aventura-ganha-trailer-e-data-de-lancamento?utm_source=rss-tech&amp;utm_medium=rss&amp;utm_campaign=rssfeed</guid>
                    <description><![CDATA['Pirates de Enchiridion' é um jogo de mundo aberto 3D]]></description>
                                            <content:encoded><![CDATA[<p>"Adventure Time: Pirates of Enchiridion" (Hora de Aventura: Piratas de Enchiridion, em tradução livre) teve o primeiro trailer divulgado nesta sexta-feira (27). Nas imagens, a Bandai Namco revela um pouco do gameplay e do mundo que será explorado por Finn, junto a Jake, Princesa Jujuba e Princesa Caroço.</p>

<p><iframe src="https://www.youtube.com/embed/jqZ3bkcmArU" width="560" height="315" frameborder="0"></iframe></p>
<p>O jogo é um RPG de mundo aberto que mostra a Terra de Ooo inundada, levando os protagonistas a uma aventura a bordo de um navio pirata.</p>
<p><a href="https://www.noticiasaominuto.com.br/tech/583870/por-tempo-limitado-microsoft-oferece-mais-de-100-jogos-por-r-1">+ Por tempo limitado, Microsoft oferece mais de 100 jogos por R$ 1</a></p>
<p>Desenvolvido pela Climax, a mesma produtora de "Silent Hill: Shattered Memories", o game será lançado em 20 de julho para PC, Nintendo Switch, PlayStation 4 e Xbox One.</p>
<p> </p>]]></content:encoded>
                                        <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">Notícias Ao Minuto</dc:creator>
                    <pubDate>Fri, 27 Apr 2018 15:25:06 -0300</pubDate>
                                            <enclosure
                                                    url="https://static.noticiasaominuto.com.br/stockimages/1920/naom_5ae36bef7b447.jpg?1524853851" 
                                                    type="image/jpeg" 
                                                    length="0" 
                                                />
                                                                                                                                                                                </item>
                </channel>
</rss>
";}')); /* Child Type: integer */ $data['createdOn'] = 1525796617;