Apple abre código da Linguagem Swift

Num movimento que representa uma mudança significativa para a Apple e para a indústria de TI ela abriu o código de sua linguagem de programação Swift em dezembro ultimo.

A Apple lançou o Swift inicialmente apenas para iOS/watchOS/tvOS (iPod, Apple Watch, iPhone, iPad, Apple TV) e para OSX (linha Mac). Ao abrir o código da linguagem a Apple está preparando o caminho para Swift ser executado em todos os tipos de máquinas, incluindo servidores com Linux, smartphones baseados no sistema operacional Android e tablets baseado no sistema operacional Windows Phone, da Microsoft.

A Apple criou um site http://Swift.org e vai compartilhar o código fonte através do repositório no GitHub. Ela também criou um ecosistema com uma ampla gama de ferramentas. a) Compilador Swift que poderá ser executado no Linux, além do Mac OSX; b) Gerenciador de pacotes para Swift;

A Apple não portou o Swift para Android ou Windows Phone, porém o código que lançou deve permitir que a comunidade open source construa software que rode potencialmente, em qualquer outro sistema operacional. Codificadores serão motivados a fazê-lo porque Swift já provou ser muito eficaz, segura e produtiva. Swift é significativamente mais fácil de aprender e usar do que Objective-C, e fornece a mesma eficiência. Empresas de grande porte como Twitter, Yahoo e LinkedIn já estão usando a nova linguagem em aparelhos da Apple e várias startups, já estão de olho nas formas de executar a linguagem em outras máquinas.

As máquinas Linux são usadas tanto nos grandes servidores e Farms das maiores empresas de tecnologia (Google, Facebook, Uber, Airbnb, etc.) como nos smartphones Android. Desta forma é muito bem vinda esta noticia de abertura da Linguagem Swift.

Em breve veremos Aplicações Swift rodando nos maiores Data Centers do planeta.

Para comemorar este fato eu criei uma imagem Docker que pode ser obtida em hub.docker.com/r/dockerbrasil/swift-2_2

Swift open source

Deixe seu nome e e-mail para que eu possa enviar cupons de desconto para o curso sobre Docker

Java 9 no Docker – Java Playground com REPL

A abordagem adotada aqui, com uso de contêiner Docker, foi motivada pela preservação do ambiente Java existente no computador Host já que instalar uma versão Java 9 onde já existe outra versão do Java, tal como o Java8, pode deixar o ambiente instável, criando problemas para o Desenvolvedor ou SysAdmin.

Criando ou Obtendo a imagem Docker

Criando

cd ~/Desktop/Development
git clone git@github.com:joao-parana/java-jdk9.git
cd java-jdk9
docker build -t parana/java-jdk9 .

Obtendo

Senão NÃO desejar fazer o build você poderá baixar direto a imagem do Docker Hub

docker pull parana/java-jdk9

Sessão do JShell

Para termos a disposição uma sessão do JShell, basta executar o Contêiner e invocar a JShell

docker run -i -t --rm parana/java-jdk9
jshell

Você verá uma mensagem parecida com esta abaixo

Jan 01, 2016 12:28:09 PM java.util.prefs.FileSystemPreferences$1 run
INFO: Created user preferences directory.
|  Welcome to JShell -- Version 9-internal
|  Type /help for help

E um prompt assim:

-> 

Agora podemos digitar código Java diretamente na console. Não exibirei o prompt abaixo para simplificar o uso dos comandos. Em vez disso colocarei o código Java e os comandos JShell em fonte de tamanho fixo.

import java.util.stream.*
IntStream.range(0, 10).map(x->x*x).forEach(System.out::println)
/save script-01.repl 
/exit

Voltamos a Bash e podemos listar os arquivos e exibir o conteudo de script-01.repl

ls
script-01.repl
cat script-01.repl 
import java.util.stream.*;
IntStream.range(0, 10).map(x->x*x).forEach(System.out::println)

Voltamos a invocar a JShell e digitar comandos Java ou comandos JShell (estes que são precedidos pelo caracter / )

Experimentemos os comandos /?, /vars e /methods

jshell
System.out.println("Agora interativamente")
/open script-01.repl 
/?
/methods

O método printf já vem definido para facilitar o uso da console REPL

printf("Oi %s", "Mundo")
int pi = 3.1416
float pi = 3.1416
float pi = 3.1416f
/vars

Experimentando os comandos /imports, /vars e /reset

/imports
/vars
/reset

Usando o comando /list para listar o código Java no contexto atual

/list

Obtendo o Histórico de comandos digitados até o momento

/history

É possível modificar o nível de LOG na console REPL do JShell com o comando /feedback

-> /feedback ?
|  Follow /feedback with of the following:
|    off       (errors and critical output only)
|    concise
|    normal
|    verbose
|    default
|  You may also use just the first letter, for example: /f c
|  In interactive mode 'default' is the same as 'normal', from a file it is the same as 'off'

O conteúdo mostrado pelo comando /? lista todas as possibilidaes de uso do JShell. Veja abaixo

Type a Java language expression, statement, or declaration.
Or type one of the following commands:

/list [all]                      -- list the source you have typed
/seteditor           -- set the external editor command to use
/edit                -- edit a source entry referenced by name or id
/drop                -- delete a source entry referenced by name or id
/save [all|history|start]  -- save:  - current source;
                                          all - source including overwritten, failed, and start-up code;
                                          history - editing history;
                                          start - default start-up definitions
/open                      -- open a file as source input
/vars                            -- list the declared variables and their values
/methods                         -- list the declared methods and their signatures
/classes                         -- list the declared classes
/imports                         -- list the imported items
/exit                            -- exit the REPL
/reset                           -- reset everything in the REPL
/feedback                 -- feedback information: off, concise, normal, verbose, default, or ?
/prompt                          -- toggle display of a prompt
/classpath                 -- add a path to the classpath
/history                         -- history of what you have typed
/setstart                  -- read file and set as the new start-up definitions
/help                            -- this help message
/?                               -- this help message
/!                               -- re-run last snippet
/                            -- re-run snippet by id
/-                            -- re-run n-th previous snippet

Supported shortcuts include:
       -- show possible completions for the current text
Shift- -- for current method or constructor invocation, show a synopsis of the method/constructor

Deixe seu nome e e-mail para que eu possa enviar cupons de desconto para o curso sobre Docker

Linha Shebang pra GoLang

Shebang GOLANG GO

Qual a forma mais apropriada para definir uma linha shebang para Script escrito em Linguagem GO ?

Existem algumas alternativas e vou descrever aqui.

A mais simples é essa abaixo:

Coloque na primeira linha do programa principal

//usr/local/go/bin/go run $0 $@ ; exit

No caso de você não saber onde está instalado o GO use o comando `which go` para verificar.

Exemplo:

//usr/local/go/bin/go run $0 $@ ; exit
package main
import "fmt"
func main() {
  fmt.Println(“Oi SysAdmin. Este é um script escrito em GO")
}

A razão para isso funcionar é a seguinte: O compilador go trata as duas barras // como comentário e a shell, por outro lado ignora a barra extra existente. Desta forma tanto a sua Shell quanto o Builder do GO irao entender corretamente o que deve ser feito.

Não se esqueça de conceder acesso de execução no arquivo .go

Supondo que o arquivo se chame hello.go podemos executar

chmod a+rx hello.go

Existem argumentações para se usar algo um pouco mais rebuscado para evitar problema de compatibilidade entre ambientes.

///usr/bin/true; exec /usr/bin/env go run "$0" "$@"

Eu prefiro usar como mostrado abaixo em ambiente de desenvolvimento..

///usr/bin/true; echo •• Executando "$0"; exec /usr/bin/env go run "$0" "$@"

Exemplo:

///usr/bin/true; echo •• Executando "$0"; exec /usr/bin/env go run "$0" "$@"
package main 
import "fmt"
func main() {
  fmt.Println(“Oi SysAdmin. Este é um script escrito em GO")
}

Deixe seu nome e e-mail para que eu possa enviar cupons de desconto para o curso sobre Docker

A linguagem GO

O começo de tudo

O panorama das linguagens de programação tem mudado drasticamente nos últimos anos. Essa coisa toda de linguagem de programação de alto nível começou com a linguagem C No clássico o trabalho do Brian Kernighan e Dennis Ritchie – The C Programming Language

logotipo GOLANG

Evolução do panorama

Posteriormente surgiram linguagens mais sofisticadas como Java, C# (.Net com um conjunto variado de linguagens suportadas na plataforma), JavaScript (dominando o cenário na WEB), TypeScript (trazendo tipagem forte para o JavaScript – patrocinado pela Microsoft). A Apple também não ficou atras e lançou recentemente uma Linguagem chamada Swift com tipagem forte que usa o LLVM – mesmo compilador usado pela National Instruments no LabView. Esta linguagem é uma grande evolução em relação a anteriormente usada pela Apple, Objective C. Swift merece um post exclusivo para discutir as vantagens implementadas.

Neste post falaremos da linguagem GO patrocinada pelo Google e de código livre. Ela surgiu em 2009 e gera código nativo nas plataformas Windows, Linux, FreeBSD e MAC OSX. A sintaxe é semelhante a linguagem C com algumas variações na gramática que estão relacionadas a declaração de tipos e ausência de parênteses nas estruturas FOR e IF, por exemplo. Ela também possui coletor de lixo (garbage colector) e um modelo de concorrência robusto. Não possui programação genérica, nem herança, nem tratamento de exceção com try catch. Também não aceita sobrecarga de métodos. Você pode, porém, usar programação funcional com clausuras. Vetores associativos fazem parte da estrutura da linguagem (algo parecido com o feito no Javascript). GO também suporta UTF-8 e pode converter de UTF-16 também.

Os compiladores GO usam a infraestrutura GNU, largamente usada em todas as plataformas.

Um programa GO começa com a declaração do pacote ou seja espaço de nomes (namespaces). Em seguida vem as declarações de importação de pacotes.

O programa principal deve declarar o método via palavra reservada func e o nome deste método deve ser main.

Em seguida usamos as estruturas da linguagem juntamente com os pacotes importados para criar as funcionalidades desejadas.

package main

import "fmt"

func main() {
    fmt.Println("Hello, 世界")
}

As estruturais existentes são aquelas típicas de sequência, seleção e repetição e como já foi provado bastam essas estruturas para resolver qualquer problema de computação.

A clausura ajuda não questão de guardar estado e permitir implementação da abordagem funcional.

Existe um site bastante útil que mostra as características da linguagem através de exemplos

A instalação da linguagem no ambiente MAC OSX da Apple é bastante simples. O mesmo ocorre no ambientes Linux e FreeBSD. No Windows você pode usar o arquivo .msi adequado a sua plataforma (32 ou 64 bits). Veja este link para Download

A propósito a linguagem GO dera código bastante eficiente e também possui pacotes nativos para lidar com o sistema de arquivos com os processos, com o ambiente e com as interfaces de rede. Você pode implementar um servidor HTTP em poucas linhas de código, como mostrado no exemplo abaixo.

Uma coisa muito em importante sobre GO é o fato do Docker usar a linguagem GO Na sua implementação. Como benefício disso você tem a possibilidade de criar Imagens de Contêineres usando a linguagem GO.

Exemplos comentados

Veja também alguns exemplos comentados neste link e deixe sua dúvida e opinião aqui no Blog.

Integracão GO com Docker.

Neste projeto do Github você pode acessar dois Dockerfiles. Um deles cria um contêiner Docker para desenvolver código GO (diretório dev) e o outro cria um contêiner Docker para colocar este código em produção sem a necessidade de se carregar um Linux completo tal como Debian ou Ubuntu (diretório prod). O contêiner de produção ficou com menos de 6 MB. Incrivel, não é mesmo ?