Programando com Kotlin

Kotlin tem causado sensação desde que foi disponibilizado como código aberto pela JetBrains em 2011. A linguagem foi elogiada por desenvolvedores no mundo todo e já está sendo adotada pelas empresas. Este livro apresenta uma introdução detalhada a Kotlin, mostrando todos os seus recursos, e possibilitará que você escreva código Kotlin para ambientes de produção.

VITRINE Os Livros mais Vendidos !

De: R$ 98,00Por: R$ 75,90

Preço a vista: R$ 75,90

Economia de R$ 22,10

+-
Comprar
Opções de Parcelamento:
  • à vista R$ 75,90
Outras formas de pagamento

Quem viu este produto , comprou

  • Dante Explica Access

    Aprenda nesta obra a elaborar sistemas profissionais com o Access dominando conceitos como: *Banco de dados e tabelas; *Registros e campos; *Chaves (única, primária, inteligente e estrangeiras); *Índices; *Relacionamentos; *Formulários; *Macros VBA (eventos, sintaxe e depuração); *Consultas; *Junções; *Resumo (agrupamento, agregação e referência cruzada); *Relatórios (estrutura, subtotais e quebra de página). ... Ler mais +

    QUERO VER
  • Dante Explica Excel

    Aprenda nesta obra a elaborar planilhas profissionais com o Excel, dominando conceitos como pasta de trabalho e planilhas; células e intervalos; sistema de coordenadas; fórmulas; atalhos para navegação; transposição de dados; alça de preenchimento; ordenação; subtotais; filtros; funções predefinidas; conversão (de-para) de valores; soma condicional; tabelas dinâmicas (referência cruzada); gráficos colunas/barras, pizza, dispersão); macros VBA (sintaxe, depuração, conectividade) e impressão. ... Ler mais +

    QUERO VER
  • Dante Explica Word

    O Microsoft® Word é o processador de textos mais usado para automação de escritórios. Aprenda nessa obra a elaborar documentos profissionais com ele. ... Ler mais +

    QUERO VER

Quem viu este produto , também se interessou

  • O Guia de Investimentos: Aprenda a ganhar dinheiro investindo como os ricos - Série Pai Rico

    VITRINE Os Livros mais Vendidos !

    Em O Guia de Investimentos você verá como lidar com as questões de insuficiência de dinheiro, como ganhá-lo e aprender a investir. ... Ler mais +

    QUERO VER
  • Gestão de Megaprojetos: Uma Abordagem Lean

    O estudo e o desenvolvimento de megaprojetos em setores como o de petróleo e gás, mineração, siderúrgicas, termoelétricas, barragens, hidroelétricas, aeroportos, entre outros, têm sido objeto de grande atenção por parte de governos e grandes empresas no Brasil e no mundo. Ao mesmo tempo, na área acadêmica vem crescendo o interesse pelo tema. Essa atenção é justificada pelas características que esses projetos apresentam: alto nível de investimentos associado a grandes riscos, sofisticação das tecnologias envolvidas, alto impacto ambiental e social e multiplicidade de agentes envolvidos, fatores que tornam esses empreendimentos bastante complexos. ... Ler mais +

    QUERO VER
  • 1000 Questões de Matemática - Escolas Militares e Ensino Médio

    VITRINE Os Livros mais Vendidos !

    1.000 QUESTÕES DE MATEMÁTICA - Escolas Militares e Ensino Médio é um livro necessário e oportuno, que vai atender uma faixa específica de estudantes do Ensino Médio de todo o país. ... Ler mais +

    QUERO VER
  • Desenvolvendo aplicações com Xamarin

    VITRINE Os Livros mais Vendidos !

    Com uma abordagem bastante didática, este livro oferece ao leitor o conhecimento necessário para o desenvolvimento de aplicações móveis para Android, iOS e Windows Mobile utilizando o Xamarin e o Visual Studio 2017. ... Ler mais +

    QUERO VER
  • Android - Do Básico ao Avançado

    A plataforma de desenvolvimento Android, apesar de relativamente nova, mostra-se robusta e estável para o desenvolvimento dos mais diversos tipos de aplicações móveis. Este livro apresenta os principais recursos utilizados no desenvolvimento de aplicações Android, desde o processo básico de preparação do ambiente e desenvolvimento do primeiro aplicativo, abordando também os principais componentes visuais da plataforma e seu modelo de tratamento de eventos, avançando para a persistência de dados, utilizando o tradicional SQLite e os métodos alternativos de persistência (arquivos, SharedPreference, entre outros). ... Ler mais +

    QUERO VER
  • Serviços de Redes em Servidores Linux

    VITRINE Os Livros mais Vendidos !

    O livro Serviços de Redes em Servidores Linux traz roteiros com o passo a passo detalhado de como instalar e configurar os principais serviços empregados em redes de computadores mediante o uso de servidores Linux baseados no Debian GNU/Linux e Ubuntu Server. Esse formato didático de apresentar conteúdo prático de maneira objetiva, sem tentar reinventar aquilo que já está consolidado em outras literaturas focadas na teoria, é característico do autor em suas publicações (livros e blog) e nas salas de aula. ... Ler mais +

    QUERO VER
  • O Gerente de Projetos Inteligente: depoimentos de quem sabe fazer projetos

    VITRINE Os Livros mais Vendidos !

    Nesta obra, os autores compartilham experiências reais, vividas ao longo de vários anos de atuação profissional. Em histórias curtas e de fácil leitura, o leitor poderá aproveitar lições aprendidas em diversos contextos do gerenciamento de projetos, mas não apenas sobre esse tema. Assuntos como gestão de pessoas, cultura organizacional, estratégia e carreira fazem parte das histórias que nos levam a pensar e a entender que a capacidade de realizar bons projetos depende de fatores que vão muito além do simples domínio de ferramentas de gestão. ... Ler mais +

    QUERO VER
  • Cabo Apple 30 pinos para USB - MA591BZ/C

    R$ 129,90 ou 2x de R$ 64,95

    Este cabo USB 2.0 conecta seu iPod, iPhone ou iPad (diretamente ou usando o dock) à porta USB do computador para carregá-lo e sincronizá-lo de forma eficiente ou ao Carregador USB da Apple para um carregamento prático na tomada elétrica. ... Ler mais +

    QUERO VER
  • Microsserviços prontos para a produção

    VITRINE Os Livros mais Vendidos !

    Um dos maiores desafios para as empresas que adotaram a arquitetura de microsserviços é a falta de padronização de arquitetura – operacional e organizacional. Depois de dividir uma aplicação monolítica ou construir um ecossistema de microsserviços a partir do zero, muitos engenheiros se perguntam o que vem a seguir. Neste livro prático, a autora Susan Fowler apresenta com profundidade um conjunto de padrões de microsserviço, aproveitando sua experiência de padronização de mais de mil microsserviços do Uber. Você aprenderá a projetar microsserviços que são estáveis, confiáveis, escaláveis, tolerantes a falhas, de alto desempenho, monitorados, documentados e preparados para qualquer catástrofe. ... Ler mais +

    QUERO VER
  • Programação Shell Linux - 11ª edição

    R$ 120,00 ou 2x de R$ 60,00

    Inédito no mercado, este livro apresenta uma abordagem descontraída da programação Shell dos sistemas operacionais Unix/Linux. De forma didática e agradável, peculiar ao autor, o livro é uma referência sobre o ambiente Shell, apresenta inúmeros exemplos úteis, com dicas e aplicações para o dia a dia dos analistas, programadores e operadores que utilizam esses sistemas operacionais. O livro está dividido em três partes: - Shell básico, que apresenta os principais comandos com suas opções mais utilizadas; - Programação em Shell propriamente dita, onde esmiúça cada um dos comandos da primeira parte e enfatiza as instruções ... Ler mais +

    QUERO VER
  • Imposto de Renda no Mercado de Ações: A tributação sobre os ganhos de pessoas físicas na bolsa de valores - 2ª Edição

    VITRINE Os Livros mais Vendidos !

    Para muitos investidores da bolsa de valores, a prestação de contas com a Receita Federal revela-se mais árdua do que de fato poderia ser. Mais preocupante do que a dificuldade experimentada no momento da declaração é a falta de atenção dos investidores em relação à própria apuração do imposto que, diferentemente do que muitos pensam, não ocorre na declaração anual. Considerando essa realidade, o objetivo do livro que você tem em mãos é, numa abordagem prática e com linguagem acessível, promover a aproximação desses dois mundos normalmente considerados complexos: bolsa de valores e tributação. Nesse sentido, o livro tem o propósito de analisar detalhadamente a tributação sobre os ganhos obtidos por pessoas físicas no mercado de ações da bolsa de valores, nas várias modalidades de negociação (à vista, a termo, futuro, opções e day trade), adotando uma abordagem prática, ampla e fundamentada. ... Ler mais +

    QUERO VER
  • Pentest em aplicações web

    VITRINE Os Livros mais Vendidos !

    Aplicações web têm um histórico extenso de vulnerabilidades, que têm sido exploradas pelos hackers. A lista de ataques conhecidos é extensa, envolvendo Cross-site Scripting, SQL Injection, unrestricted file upload, Code Injection, Command Injecion, Remote/Local File Inclusion e Cross-site Request Forgery, somente para citar alguns. ... Ler mais +

    QUERO VER
  • Descrição
    Programando com Kotlin

    Kotlin tem causado sensação desde que foi disponibilizado como código aberto pela JetBrains em 2011. A linguagem foi elogiada por desenvolvedores no mundo todo e já está sendo adotada pelas empresas. Este livro apresenta uma introdução detalhada a Kotlin, mostrando todos os seus recursos, e possibilitará que você escreva código Kotlin para ambientes de produção.

    Começaremos pelo básico: deixaremos você se familiarizar com a execução de código Kotlin, configurar ferramentas e apresentar instruções que poderão ser usadas para escrever programas básicos. Em seguida, discutiremos códigos orientados a objetos – funções, lambdas e propriedades –, tudo isso enquanto utilizamos os novos recursos de Kotlin.

    Então, prosseguiremos discutindo aspectos sobre null safety (segurança de nulos) e parametrização de tipos. Mostraremos como desestruturar expressões e até mesmo escrever suas próprias expressões. Também abordaremos tópicos importantes, como testes, concorrência, microsserviços e muito mais. No final deste livro, você será capaz de compor diferentes serviços e construir suas próprias aplicações.

    Você aprenderá a:

    utilizar novos recursos para escrever código orientado a objetos estruturado e legível;
    usar lambdas e funções de alta ordem para escrever um código limpo, reutilizável e simples;
    escrever testes de unidade e integrar testes de Kotlin com código Java em uma base de código em transição;
    escrever código de produção para o mundo real em Kotlin no estilo de microsserviços;
    tirar proveito das extensões de Kotlin para usar a biblioteca de coleções de Java;
    escrever código que evite erros de ponteiros nulos e ver como um código Java nullable pode ser integrado aos recursos de uma base de código Kotlin;
    escrever funções em Kotlin, conhecer novos recursos disponíveis e estender as bibliotecas existentes.
  • Sobre o Autor
  • Especificação

    Características

    Tipo de LivroLivro Físico

    Especificações

    Sobre o AutorStephen Samuel

    Stephen Samuel é um desenvolvedor talentoso, com mais de 17 anos de experiência. Trabalhou com Java ao longo de sua carreira e, nos últimos cinco anos, concentrou-se em Scala. Tem paixão por concorrência e tecnologias de Big Data. Passou os últimos anos na área de investimentos bancários e, atualmente, trabalha com Kotlin em um grande projeto de Big Data. Stephen também é ativo na comunidade de código aberto e autor de diversas bibliotecas proeminentes de Scala e Kotlin.

    Stefan Bocutiu

    Stefan Bocutiu é consultor de Big Data, com mais de 13 anos de experiência em desenvolvimento de software. Gosta de programar em Scala e C# e tem paixão por tecnologias de processamento de streams. Com a equipe da DataMountaineer – uma empresa de consultoria que oferece soluções para plataformas de streaming/fast data –, Stefan tem como foco prover pipelines de dados escaláveis, unificados e em tempo real que permitam uma tomada de decisões reativa, análise de dados (analytics) e integração com Hadoop. Stefan é apaixonado por esportes automobilísticos; embora suas habilidades com corridas não sejam boas o suficiente para lhe permitir competir, procura comparecer ao máximo possível de corridas de MotoGP. Quando não está programando, Stefan pode ser encontrado na parede de escalada ou na academia. Ocasionalmente, fazer trilhas e montanhismo está em seu calendário e, durante o inverno, viagens para esquiar são obrigatórias para ele.
    Informações TécnicasSumário
    Prefácio .................................................................................................................................15

    Capítulo 1 Introdução à linguagem Kotlin.............................................................................20
    Usando a linha de comando para compilar e executar código Kotlin..........................21
    Runtime de Kotlin................................................................................................... 23
    REPL.......................................................................................................................24
    Kotlin para scripting ................................................................................................24
    Kotlin com Gradle................................................................................................... 25
    Kotlin com Maven....................................................................................................28
    IntelliJ e Kotlin.........................................................................................................32
    Eclipse e Kotlin........................................................................................................36
    Misturando Kotlin e Java em um projeto...................................................................37
    Resumo .................................................................................................................. 44

    Capítulo 2 Básico sobre Kotlin ..............................................................................................45
    Vals e vars................................................................................................................45
    Inferência de tipo .................................................................................................... 46
    Tipos básicos...........................................................................................................47
    Números ............................................................................................................47
    Booleanos...........................................................................................................49
    Chars .................................................................................................................49
    Strings................................................................................................................49
    Arrays ................................................................................................................50
    Comentários............................................................................................................50
    Pacotes ....................................................................................................................51
    Importações.............................................................................................................51
    Importações com caractere-curinga .....................................................................51
    Renomeando na importação................................................................................52
    Templates de string ..................................................................................................52
    Intervalos.................................................................................................................53
    Laços.......................................................................................................................54
    Tratamento de exceções ...........................................................................................56
    Instanciando classes.................................................................................................57
    Igualdade referencial e igualdade estrutural ..............................................................57
    Expressão this..........................................................................................................58
    Escopo ...............................................................................................................58
    Modificadores de visibilidade ...................................................................................59
    Private ................................................................................................................59
    Protected ........................................................................................................... 60
    Internal ............................................................................................................. 60
    Controle de fluxo como expressões.......................................................................... 60
    Sintaxe de null .........................................................................................................61
    Verificação de tipos e casting...............................................................................62
    Casts inteligentes................................................................................................62
    Casting explícito................................................................................................ 64
    Expressão when...................................................................................................... 64
    When (valor).......................................................................................................65
    When sem argumento .........................................................................................67
    Retorno de função...............................................................................................67
    Hierarquia de tipos ..................................................................................................69
    Resumo ...................................................................................................................70

    Capítulo 3 Programação orientada a objetos em Kotlin.........................................................71
    Classes ....................................................................................................................73
    Níveis de acesso ..................................................................................................76
    Classes aninhadas.............................................................................................. 77
    Classes de dados.................................................................................................79
    Classes enum..................................................................................................... 80
    Métodos estáticos e objetos companheiros...........................................................81
    Interfaces.................................................................................................................87
    Herança...................................................................................................................91
    Modificadores de visibilidade ...................................................................................94
    Classes abstratas......................................................................................................96
    Interface ou classe abstrata.......................................................................................97
    Polimorfismo ...........................................................................................................98
    Regras para sobrescrita ..........................................................................................104
    Herança versus composição....................................................................................107
    Delegação de classe ................................................................................................109
    Classes seladas.......................................................................................................111
    Resumo .................................................................................................................112

    Capítulo 4 Funções em Kotlin ............................................................................................. 113
    Definindo funções..................................................................................................113
    Funções com uma única expressão ......................................................................... 114
    Funções-membro ...................................................................................................115
    Funções locais .......................................................................................................116
    Funções de nível superior.......................................................................................119
    Parâmetros nomeados ............................................................................................120
    Parâmetros default .................................................................................................121
    Funções de extensão ..............................................................................................123
    Precedência para funções de extensão................................................................125
    Funções de extensão em nulls............................................................................127
    Funções-membro de extensão ...........................................................................127
    Sobrescrevendo funções-membro de extensão....................................................128
    Extensões em objetos companheiros..................................................................130
    Múltiplos valores de retorno ..............................................................................131
    Funções infixas.................................................................................................132
    Operadores............................................................................................................134
    Sobrecarga de operadores..................................................................................135
    Operadores básicos...........................................................................................137
    in/contains .......................................................................................................137
    get/set...............................................................................................................138
    Comparação .....................................................................................................140
    Atribuição ........................................................................................................140
    Interoperabilidade com Java .............................................................................. 141
    Funções literais......................................................................................................142
    Funções tail recursive.............................................................................................143
    varargs...................................................................................................................145
    Operador de spread...........................................................................................146
    Funções da biblioteca-padrão .................................................................................146
    apply ................................................................................................................146
    let.....................................................................................................................147
    with..................................................................................................................147
    run...................................................................................................................148
    lazy ..................................................................................................................148
    use ...................................................................................................................149
    repeat ...............................................................................................................149
    require/assert/check..........................................................................................149
    Funções genéricas..................................................................................................150
    Funções puras........................................................................................................151
    Java a partir de Kotlin ............................................................................................153
    Getters e setters ................................................................................................153
    Métodos abstratos únicos..................................................................................154
    Escapando identificadores de Kotlin ..................................................................155
    Exceções verificadas..........................................................................................155
    Métodos void em Java .......................................................................................155
    Kotlin a partir de Java ............................................................................................156
    Funções de nível superior..................................................................................156
    Parâmetros default ............................................................................................157
    Objetos e métodos estáticos...............................................................................157
    Nomes em caso de apagamento (erasure)...........................................................158
    Captura de exceções verificadas ........................................................................159
    Resumo .................................................................................................................159

    Capítulo 5 Funções de ordem superior e programação funcional .........................................160
    Funções de ordem superior.....................................................................................160
    Devolvendo uma função....................................................................................162
    Atribuição de função.........................................................................................163
    Closures ................................................................................................................164
    Funções anônimas .................................................................................................165
    Referências a funções.............................................................................................166
    Referências a funções de nível superior ..............................................................166
    Referências a funções-membro e a funções de extensão......................................166
    Referências vinculadas......................................................................................167
    Receptores de funções literais.................................................................................168
    Funções na JVM ....................................................................................................169
    Bytecode...........................................................................................................169
    Composição de funções..........................................................................................171
    Funções inline .......................................................................................................173
    Noinline ...........................................................................................................177
    Currying e aplicação parcial ...................................................................................178
    Currying em ação .............................................................................................179
    Acrescentando suporte a currying .....................................................................180
    Memoização ..........................................................................................................181
    Implementando a memoização ..........................................................................183
    Alias de tipo ..........................................................................................................184
    Either ....................................................................................................................186
    fold...................................................................................................................186
    Projeção............................................................................................................187
    Outras funções de projeção ...............................................................................189
    Sumário 9
    DSLs personalizadas..............................................................................................191
    Funções infixas como palavras reservadas .........................................................192
    Usando receptores de função em uma DSL ........................................................195
    Validação e acúmulo de erros .................................................................................197
    Resumo .................................................................................................................200

    Capítulo 6 Propriedades.....................................................................................................201
    Por que usar propriedades?.....................................................................................201
    Sintaxe e variações.................................................................................................204
    Visibilidade............................................................................................................207
    Inicialização tardia.................................................................................................208
    Propriedades delegadas ..........................................................................................209
    Inicializações preguiçosas.......................................................................................216
    lateinit versus lazy..................................................................................................221
    Observáveis ...........................................................................................................222
    Delegação de uma propriedade diferente de null......................................................223
    Propriedades ou métodos?......................................................................................224
    Resumo .................................................................................................................225

    Capítulo 7 Null safety, reflexão e anotações........................................................................226
    Tipos nullable ........................................................................................................227
    Cast inteligente ......................................................................................................228
    Acesso seguro de null.............................................................................................228
    Operador force..................................................................................................230
    Operador Elvis.......................................................................................................231
    Casting seguro.......................................................................................................232
    Opcionais..............................................................................................................232
    Criando e devolvendo um Optional...................................................................233
    Usando um Optional ........................................................................................233
    Reflexão ................................................................................................................234
    KClass..............................................................................................................235
    Instanciação usando reflexão.............................................................................236
    Construtores..........................................................................................................238
    Instanciação com callBy ....................................................................................239
    Objetos e companheiros.........................................................................................241
    Propriedades úteis de KClass..................................................................................242
    Funções e propriedades reflexivas...........................................................................243
    Chamando uma função de modo reflexivo.........................................................245
    Variantes declaradas e não declaradas................................................................245
    10 Programando com Kotlin
    Anotações..............................................................................................................246
    Parâmetros de anotações...................................................................................247
    Anotações-padrão..................................................................................................248
    @JvmName......................................................................................................248
    @JvmStatic.......................................................................................................249
    @Throws .........................................................................................................249
    @JvmOverloads................................................................................................251
    Descoberta de anotações em tempo de execução.....................................................252
    Resumo .................................................................................................................253

    Capítulo 8 Genéricos..........................................................................................................254
    Funções parametrizadas.........................................................................................254
    Tipos parametrizados.............................................................................................256
    Polimorfismo restrito..............................................................................................257
    Limites superiores.............................................................................................257
    Vários limites....................................................................................................258
    Variância de tipos ..................................................................................................259
    Invariância........................................................................................................259
    Covariância ......................................................................................................261
    Tipo de retorno covariante ................................................................................262
    Contravariância ................................................................................................263
    Visão geral sobre variância ................................................................................266
    Tipo Nothing.........................................................................................................267
    Projeção de tipos....................................................................................................268
    Apagamento de tipo ...............................................................................................270
    Reificação de tipos .................................................................................................274
    Limites de tipos recursivos .....................................................................................276
    Tipos de dados algébricos.......................................................................................279
    Resumo .................................................................................................................284

    Capítulo 9 Classes de dados................................................................................................285
    Criação automática de getters e setters....................................................................287
    Método copy..........................................................................................................288
    toString automático................................................................................................293
    Métodos hashCode e equals gerados para você .......................................................294
    Declarações desestruturadas ..................................................................................297
    Desestruturando tipos............................................................................................299
    Regras para definição de classe de dados.................................................................300
    Limitações.............................................................................................................303
    Resumo .................................................................................................................3

    Capítulo 10 Coleções..........................................................................................................304
    Hierarquia de classes..............................................................................................304
    Arrays....................................................................................................................313
    Listas.....................................................................................................................323
    Mapas ...................................................................................................................328
    Conjuntos..............................................................................................................331
    Visões somente de leitura .......................................................................................334
    Acesso indexado ....................................................................................................335
    Sequências.............................................................................................................336
    Resumo .................................................................................................................341

    Capítulo 11 Testes em Kotlin ..............................................................................................342
    Introdução.............................................................................................................342
    Selecionando uma spec ..........................................................................................343
    Matchers................................................................................................................347
    Matchers de string ............................................................................................347
    Matchers de coleção..........................................................................................347
    Matchers de ponto flutuante..............................................................................348
    Esperando exceções..........................................................................................348
    Combinando matchers......................................................................................349
    Matchers personalizados...................................................................................350
    Inspetores..............................................................................................................353
    Interceptadores......................................................................................................355
    Interceptador de caso de teste............................................................................355
    Interceptador de spec ........................................................................................356
    Config do projeto...................................................................................................357
    Testes de propriedade.............................................................................................358
    Especificando um gerador .................................................................................359
    Testes orientados a tabela.......................................................................................360
    Testando um código não determinístico.............................................................361
    Tags, condições e config .........................................................................................363
    Config ..............................................................................................................363
    Condições ........................................................................................................364
    Tags..................................................................................................................365
    Recursos...........................................................................................................366
    Resumo .................................................................................................................366

    Capítulo 12 Microsserviços com Kotlin ................................................................................367
    Definição...............................................................................................................368
    Desvantagens.........................................................................................................372
    Por que usar microsserviços? ..................................................................................373
    12 Programando com Kotlin
    Lagom ...................................................................................................................374
    Definindo serviços .................................................................................................384
    Implementando um serviço Lagom.........................................................................387
    Resumo .................................................................................................................392

    Capítulo 13 Concorrência ...................................................................................................393
    Threads.................................................................................................................394
    Bloqueio ...........................................................................................................395
    Deadlocks e livelocks.............................................................................................401
    O problema do jantar dos filósofos ....................................................................401
    Executores.............................................................................................................403
    Condições de concorrência.................................................................................... 404
    Monitores........................................................................................................ 406
    Locks .............................................................................................................. 408
    Semáforos.........................................................................................................410
    Coleções concorrentes....................................................................................... 414
    Variáveis atômicas............................................................................................. 416
    CountDownLatch............................................................................................. 417
    Barreira cíclica ..................................................................................................419
    E/S não bloqueante e programação assíncrona ...................................................421
    Futures.............................................................................................................422
    Resumo .................................................................................................................424

    Informações Técnicas

    Nº de páginas:424
    Origem:Internacional
    Editora:Editora Novatec
    Idioma:Português
    Edição:1ª Edição
    Ano:2017
    ISBN:9788575226056
    Encadernação:Brochura
    Autor:Stephen Samuel, Stefan Bocutiu
  • Informações

Avaliação técnica sobre o livro

Olá! Seja Bem Vindo (a)!

Eu sou o Moderninho , o Mascote da Ciência Moderna Online!
Além de bonito, o novo site tem Minhas Dicas :) #ficaadica

A 1ª Dica é -> Deixe aqui seu contato para receber nossas
NOVIDADES, PROMOÇÕES E CUPONS DE DESCONTOS ;)

Navegue SEM Moderação!