Why Should You Care About Software Maintainability?

Real quick: This essay is mainly written for those who are not a software developer yet, or don’t code as their principal source of income.

Hey guys, as you all may know (for those who don’t, I’m going to explain it real quick here) I changed jobs, and now, I’m working for a bank in Brazil (I won’t share it’s name here as I’m not paid for advertising them). Coding is a side thing in my career there, I mainly work with investment analysis inside Excel (VBA) and other Microsoft applications. Investment things are very nice, but Excel sucks.

As I’ve seen there, lots of people from Investment Banking are using programming languages to get their work done faster and better than before, which is great, but the point is: Are those codes produced by non-software engineer people maintainable in a production scenario?

Software engineers who care about their code quality, make their code thinking of: error handling, data IO, test-driven development, code readability, code complexity and many other aspects that beginners and non-expert people.

Why should I f*****g care about software maintainability?

If your code will only be used by you for a task, you shouldn’t care a lot for these, your code needs to solve your problem mainly, but when you are working with multiple people in the same project/field/area/department/whatever, you won’t be the only one who will use what you are coding.

For maintainability purposes, Python, created two PEPs that should be followed as a good practice for software engineering. Those PEPs are:

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

As shown above, the simplicity and readability counts when developing new software that will be used.

Imagine if you get into a company and there is no documentation about that code, no deploy instructions, no development setup, just the code there. Would you be able to pick it up and continue working where the other people left it? Probably not, we all need best practices for better code maintenance and developers on-boarding on new systems! Maintaining a big code base without good practices is like this meme:

Image result for everything is fine dog meme

The best coding practices are those who all developers in your team know and apply, as well as can be passed to new developers. Here are some use cases of best practices that may be useful:

  • If well written comments (or docstrings) are helpful inside your code base and guide new developers to the maintenance, keep them and update those that need to be updated. Don’t keep dull comments, such as:

# Example of a dull comment

a = 1 + 2 # this line adds 1 with 2 and saves to

# Example of a needed comment

def really_cool_function_that_sums_to_numbers(x, y):
    # This function sums X and Y and returns both

If you need to comment multiple lines of your code to make it understandable, its a good time to think on how to improve it. Code should be readable and easily understandable (PEP 20 lesson here)

  • Functions should do just a single function (sounds redundant, right?) as like Pure Functions (concept from functional programming that states functions that cannot cause side effects to global variables and other functions).

There are plenty of best practices and code styling guides to follow according to your language of choice. The main point of this text is: remember that other developers will maintain your code on a near future, and you will probably maintain it too and won’t remember lots of things. Make your code simple so people understand it and continue your work.

Trazendo modelos de Object Detection API ao Google App Engine

Por vários motivos você pode querer postar um modelo de machine learning feito no Tensorflow em sua conta no Google Cloud Platform. Embora não seja a aplicação mais apropriada do Google para realizar isto (esta aplicação seria o Cloud Machine Learning), o Google App Engine consegue rodar o modelo através de um Docker e resolver o problema.

Supondo que você tenha uma aplicação que rode em um container Ubuntu (seja uma API, Frontend ou qualquer outro formato que você for usar) que faça a borda com o backend de machine learning, você precisará adicionar o Protobuffer Compiler ao seu Docker.

Para fazer isto, basta você adicionar algumas linhas de código

RUN apt-get install -y protobuf-compiler python-pil python-lxml

Iniciando com Tensorflow no Python

Olá Mundo e Pessoas! Hoje eu vou mostrar um pouco da biblioteca de deep learning e processamento de matrizes numéricas do Google: o Tensorflow!

O que é Tensorflow?

Tensorflow é uma biblioteca de computação numérica open-source criada pelo Google. Ela se utiliza de um conceito chamado data flow, ou fluxo de dados, em estruturas chamadas tensors, tensores em português, que seriam arrays de n-dimensões (onde n > 1) e nestes arrays, todas as linhas e colunas devem ser preenchidas com o mesmo tipo de valor, no caso, números (afinal só conseguimos processar algo no computador a partir de valores numéricos).

Grafos e sessões

A computação do Tensorflow é toda inspirada na teoria dos grafos: onde que cada um dos nós representa uma operação e cada aresta representa um dado a ser colocado nas operações, como mostrado na imagem abaixo:

Hello World no Tensorflow

Para montarmos um exemplo de Hello World no Tensorflow nós utilizamos o seguinte código:

import tensorflow as tf

hello = tf.constant('Hello, TensorFlow!')

x = tf.constant(5)

y = tf.constant(10)

z = tf.add(x ,y)

# Start tf session
sess = tf.Session()

# Run graph
print(sess.run(hello))

print(sess.run(z))

Na primeira linha do código nós estamos importando a biblioteca (tensorflow) para podermos ter acesso as operações e aos tipos de dados disponibilizados.

Das linhas 3 a 9, nós temos a definição de variáveis e, especialmente na linha 9, definimos uma variável no Python que recebe o resultado de uma operação de adição do Tensorflow.

Na linha 12 nós definimos a variável session que guardará a sessão do Tensorflow que rodará nossas operações e processará nossas variáveis.

Nas linhas 15 e 17 nós rodamos os processamentos das operações definidas nas linhas 3 e 9, ou seja: escreveremos Hello World na tela e somaremos os números X e Y e mostraremos o resultado.

Por enquanto é só! Não tem nada de muito aprofundado neste post, é mais para alguém poder tirar suas dúvidas do Tensorflow e poder permitir de consulta para a minha pessoa quando for necessário!

Iniciando com Machine Learning (em Python)

Olá pessoal, sejam bem vindos ao meu blog (coisa que eu finalmente estou revivendo após 1 ano sem nenhuma atividade relevante ou coisa do gênero), desta vez, tentarei trazer conteúdo mais frequentemente e também publicar minhas descobertas das áreas que eu tenho tido como hobby ou trabalho.

Atualmente estou bem focado no desenvolvimento e na aplicação de métodos de Machine Learning para diversas aplicações comerciais e na minha pesquisa no Instituto Butantan (amo esse lugar ahaha), e para poder permitir que mais pessoas tenham esse conhecimento, eu bolei uma palestra que já foi no TDC 2017, TOTVS Community Day(?, acho que é este o nome, mas whatever) e na Campus Party 2017. O vídeo da palestra está aqui abaixo para quem quiser ver e aprender mais! Além disto, irei disponibilizar os slides abaixo também, para você poder tirar dúvidas em meu material!

Versão 1.0.1 do WP-A e GoLang

Olá meus caros amigos e leitores deste blog que deve ter menos que uma alma infeliz lendo! Seja bem vindo a mais um post, desta vez eu irei falar sobre dois assuntos distintos, mas que estão relacionados a uma persona: a minha.

Então vamos ao post….

Bom, como vocês sabem, eu venho trabalhado há alguns anos em um projeto de encurtador de URL chamado WP-A, ele é escrito em Python 3.4.1 e está rodando nesta url: http://wp-a.co ! Você também pode ajudar a colaborar com o WP-A com seus conhecimentos de linguagem e etc ao entrar no meu repositório do GitHub e clicando no repositório do WP-A.

Este é o fim da seção Jabá de Programa que eu queria fazer neste post, portanto vamos realmente ao que interessa.

Estou aprendendo GoLang… Sim, finalmente mais uma linguagem diferente para preencher meu repertório de Back-End e poder desenvolver muito mais aplicações úteis para as pessoas e resolver os problemas de muitos usuários da Internet.

A linguagem Go é simples e bem eficaz para quem quer aprender uma linguagem de nível relativamente baixo e com bastante possibilidades de entendimento fácil. Bastou um dia(cerca de 4 horas de dedicação full-time) e grande parte da sintaxe estava aprendida e pronta para ser utilizada em algum projeto que tem necessidade de implantação rápida(A minha implantação não é mais rápida do que a com Python, pois j;a mexo com a linguagem há alguns anos).

Em breve espero trazer mais conteúdo sobre Python e GoLang, que são dois assuntos que eu gostaria muito de estar abordando com todos vocês que lêem este blog e acreditam que eu possa estar ajudando em suas escolhas na vida de programador. Para terminar, deixo uma tirinha do meu caro amigo @ProgramadorReal dono do Vida de Programador:

Tirinha do Vida de Programador