Numa palestra recente, eu [Paul] disse algo que perturbou muitas pessoas: que poderia-se conseguir programadores mais espertos para trabalhar num projeto com Python do que se conseguiria para trabalhar num projeto com Java.

Eu não quis dizer com isso que programadores Java são burros. O que eu quis dizer é que programadores Python são espertos. Dá muito trabalho aprender uma nova linguagem de programação. E as pessoas não aprendem Python porque ela vá lhes garantir um trabalho; elas a aprendem pois genuinamente gostam de porgramar e não estão satisfeitas com as linguagens de programação que elas já conhecem.

Isso faz dessas pessoas exatamente o tipo de programadores que as empresas deveriam estar interessadas em contratar. Daí que, por falta de um nome melhor, eu vou chamar de “O Paradoxo Python”: se uma empresa escolhe escrever seu software numa linguagem comparativamente esotérica, ela vai ter a possibilidade de contratar programadores melhores, pois ela vai atrair somente aqueles que se interessaram/preocuparam o suficiente para aprender anteriormente a linguagem. E no caso dos programadores o paradoxo é ainda mais pronunciado: a linguagem a se aprender, se você quer conseguir um emprego, é a linguagem que as pessoas não apredem somente para conseguir um emprego.

Apenas poucas companhias tem sido espertas o suficiente para perceber isso até agora. Mas existe um tipo de seleção acontecendo nesse caso também: essas são exatamente as empresas para as quais os programadores gostariam mais de trabalhar. O Google, por exemplo. Quando eles fazem chamadas para empregos para programção em Java, eles também querem e pedem experiência em Python.

Um amigo meu que sabe quase todas as linguagens de programação amplamente usadas usa Python para a maioria dos seus projetos. Ele diz que a razão principal é que ele gosta do jeito que o código fonte fica [quão bonito ele fica]. Essa pode parecer uma razão frívola para se escolher uma linguagem de programação em relação a outra. Mas não é tão frívola quanto parece: quando você programa, você passa bem mais tempo lendo código do que escrevendo. Você move pedaços de código de um lado para o outro como um escultor faz com pedaços de argila. Então uma linguagem de programação que faça com que o código fique feio é enlouquecedora para um programador exigente, assim como argila cheia de protuberâncias seria para um escultor.

A mera menção de código fonte “feio”, muitas pessoas vão logo obviamente pensar em Perl. Mas a feiura superficial de Perl não é o tipo de feiura ao qual me refiro. Feiura de verdade não é a sintaxe áspera ao olhar(harsh-looking), mas sim ter que construir programas a partir dos conceitos errados. Perl pode parecer com um personagem de desenho animado xingando, mas existem casos onde Perl é até mesmo melhor que Python conceitualmente.

Até agora, pelo menos. Ambas as linguagem obviamente são alvos móveis. Mas elas compartilham, assim como com Ruby (e Icon, e Joy, e J, e Lisp, e Smalltalk), o fato que elas foram criadas por, e usadas por, pessoas realmente interessadas em programação. E estas linguagem são as que tendem a fazer o serviço melhor.

import xlrd
from lxml.html import builder as E, tostring
from lxml.etree import ElementTree

def itermeth(obj, method, endattr):
    for index in xrange(getattr(obj, endattr)):
        yield getattr(obj, method)(index)

def xls_tree(xls_filename, header=True, tableattrs=None):
    if tableattrs is None:
        tableattrs = {}
    workbook = xlrd.open_workbook(xls_filename)
    head = E.HEAD(E.TITLE(xls_filename))
    body = E.BODY()
    for sheet in workbook.sheets():
        if sheet.nrows <= 0 or sheet.ncols <= 0:
            continue # sheet is empty
        table = E.TABLE(E.CAPTION(sheet.name), **tableattrs)
        container = E.THEAD()
        table.append(container)
        cellClass = E.TH
        for xlsrow in itermeth(sheet, 'row', 'nrows'):
            row = E.TR()
            container.append(row)
            if header:
                container = E.TBODY()
                table.append(container)
                cellClass = E.TD
                header = False
            for cell in xlsrow:
                row.append(cellClass(unicode(cell.value)))
        body.append(table)
    return ElementTree(E.HTML(head, body))

## Example usage:
html = xls_tree('/home/nosklo/Documentos/teste.xls',
    tableattrs={'class': 'mytable', 'border': '2'})
# print to screen
print tostring(html, pretty_print=True)
# write to file
html.write('/tmp/resultado.html')

Achei muito interessante o fato de conseguir envolver a todos, muita gente está tentando escrever o algoritmo.

O problema consiste em fazer um algoritmo que ao receber uma lista de números inteiros, retorne uma sublista cuja soma é zero.

Porém, tem os seguintes modificadores:

Nada como alguns exemplos para entender melhor:

• Para a lista [-5, -3, 10, 16] não tem nenhuma sublista que dê zero, então o algoritmo deve retornar a lista vazia []
• No caso da lista [-5, -3, 3, 10] o algoritmo deve calcular a sublista [-3, 3] (cuja soma dá 0).
• Porém, se a lista é [-15, -3, 3, 18] o algortmo tem duas possibilidades cuja soma é zero:
  • retornar [-3, 3] (soma 0)
  • retornar [-15, -3, 18] (soma 0)

Quando isso ocorrer, o algoritmo deve estar montado de forma a retornar a sublista com maior valor absoluto, ou seja, [-15, -3, 18] (soma absoluta 36).

Após intensiva pesquisa, encontrei isto na wikipedia. O problema é da classe NP-Hard, e não existe solução linear. Porém com uma linguagem dinâmica, é possível fazer soluções pseudo-polinomiais.

O que estou procurando é justamente este algoritmo otimizado.

Resolvi desenvolver primeiramente o programa de referência. Este programa encontra a solução do problema através da força bruta, ou seja, gera todas as possibilidades de combinações existentes, soma cada uma pra encontrar as combinações cuja soma é zero, e depois verifica qual delas é a que tem maior valor absoluto. A resposta deste código sempre está correta, porém, o tempo para gerar todas as possibilidades é quadrático e dobra a cada novo ítem acrescentado na lista.

Aqui está o programa de referência:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright © 2010 Clóvis Fabrício Costa
# Licensed under GPL version 3.0 or higher 

from itertools import chain, combinations

def acha_combinacao(itens):
    """
    Função que resolve o problema "subset sum" através da geração de todas
    as possibilidades.
    
    Passe uma lista de números inteiros, e a função retornará uma sublista
    cuja soma é zero. 
    
    Caso não exista nenhuma sublista que alcance zero, a lista vazia será
    retornada.
    
    Caso exista mais de uma sublista que tem zero, o algoritmo deve encontrar
    aquela que tem o maior valor absoluto, ou seja, o maior valor 
    desconsiderando o sinal (módulo).
    
    Em caso de empate, qualquer uma das combinações pode ser retornada.
    """
    # gera todas as combinações possíveis
    todas_combs = chain.from_iterable(combinations(itens, n+1)
                                   for n in xrange(len(itens)))
    # procura a maior
    maior_comb = []
    maior_somaabs = 0
    for comb in todas_combs:
        if sum(comb) != 0:
            continue # Combinação não dá zero, pulando.
        somaabs = sum([abs(item) for item in comb])
        if somaabs > maior_somaabs:
            maior_comb = comb
            maior_somaabs = somaabs
    return maior_comb

Para quem quiser tentar fazer o seu algoritmo, estou disponibilizando em meu repositório o programa de referência acima, todas as minhas tentativas até agora, um arquivo de dados contendo números para teste com a respectiva resposta correta, e um programa que lê este arquivo de dados e testa a sua função automaticamente. Desta forma fica fácil achar os problemas do código.

A versão disponibilizada no repositório é compatível com versões do python < 2.6 (o código acima não é).

O repositório está hospedado no bitbucket, e pode ser baixado utilizando o mercurial, com o seguinte comando:

hg clone http://bitbucket.org/nosklo/subset_sum

Para testar seu código, coloque seu arquivo contendo o código na mesma pasta onde você baixou o repositório acima e use o seguinte modelo:

1
2

import referencia
referencia.teste(sua_funcao)

Isso é o suficiente. A sua função será testada com todos os dados de teste que gerei, e vai mostrar qualquer erro encontrado nos resultados.

Qualquer dúvida, estou no canal #python-br da freenode. Muito obrigado a todos que estão ajudando a encontrar este algoritmo.

O livro está na Gnu FDL. O primeiro passo é arrumar o fonte do livro.

O renatopp já criou um projeto aqui pra gente publicar a tradução.

\o/

Vamos testar enquanto ainda está quente!!

Download aqui.

• Crie uma pasta para seu projeto. Por exemplo, se seu projeto se chama NetoChat, crie uma pasta NetoChat para ser a raiz do seu projeto. Quando você lançar uma versão, inclua um sufixo de versão: NetoChat-2.5
• Crie dentro desta pasta um pacote python para conter o fonte do seu projeto. Dê a ela um nome sem traços e sem espaços, somente com letras minúsculas. Exemplo: NetoChat/netochat. Crie um arquivo __init__.py vazio dentro desta pasta para que ela seja considerada um pacote. NetoChat/netochat/__init__.py
• Coloque seus módulos lá dentro do pacote: NetoChat/netochat/interface.py NetoChat/netochat/rede.py
• Você também pode organizar em subpacotes. Primeiro crie NetoChat/netochat/eventos/__init__.py para criar um pacote eventos. Em seguida crie seus módulos lá dentro, por exemplo, NetoChat/netochat/eventos/som.py Fazendo desta forma, estes módulos podem ser chamados facilmente de forma absoluta, sem ambiguidades nem confusões. Exemplos:
  • from netochat.eventos import som
  • from netochat import rede
• Crie uma pasta NetoChat/bin onde você colocará seus executáveis. Estes executáveis devem ser scripts python sem a extensão .py, que possuem somente uma linha importando e executando uma função que deve estar definida em outro ponto do projeto. Não coloque o código em si nestes scripts, apenas a chamada. Exemplo, NetoChat/bin/nchat:
  • from netochat.interface import main_window ; main_window()
• Ponha seus testes de unidade em um outro pacote python. Mais uma vez, isto implica em criar o pacote (NetoChat/tests/__init__.py)  e colocar seus testes lá (NetoChat/tests/test_rede.py, NetoChat/tests/test_interface.py)
• Adicione alguns arquivos que é sempre bom ter:
  • NetoChat/setup.py – programa de instalação criado com distutils para instalar seu programa e registrá-lo automaticamente;
  • NetoChat/README – descrição do seu programa;
  • NetoChat/LICENSE – licença de distribuição do seu código;
  • NetoChat/TODO, NetoChat/INSTALL, etc

A estrutura do código ficaria assim:

• NetoChat/
  • setup.py
  • README
  • bin/
    • nchat
  • netochat/
    • __init__.py
    • interface.py
    • rede.py
    • eventos
      • __init__.py
      • som.py
    • tests/
      • __init__.py
      • test_interface.py
      • test_rede.py

Por favor, não faça, repito, não faça as coisas abaixo:

• NÃO coloque seu código fonte em uma pasta chamada lib ou src – dificulta a execução do seu código sem instalá-lo.
• NÃO ponha seus testes fora do pacote python principal do seu projeto – dificulta a execução dos testes em uma versão instalada do código
• NÃO crie um pacote com apenas um __init__.py e ponha o código todo em __init__.py. Simplesmente crie um módulo comum ao invés de um pacote. É mais simples.
• NÃO tente criar gambiarras e usar magia negra para fazer seu módulo ser importável sem que o usuário tenha que adicioná-lo ao caminho de importação dele (através de PYTHONPATH, setup.py ou qualquer outro mecanismo). Você com certeza vai deixar algo faltando e seu programa não vai rodar em alguma plataforma ou caso específico se você tentar assim. Simplesmente crie o setup.py usando distutils e ele fará a coisa certa automaticamente.

Leia em seguida a conversa de irc que deu origem a este post (uma das muitas vezes que respondi essa dúvida):

<xNetoXMartinsx> nosklo, estou começando ainda… sorry!
<nosklo> xNetoXMartinsx: sim, sim, veja vou te explicar
<nosklo> xNetoXMartinsx: suponha q seu projeto seja um cliente de IRC e chame NetoChat
<nosklo> xNetoXMartinsx: vc cria uma pasta NetoChat para conter o projeto
<nosklo> xNetoXMartinsx: dentro desta pasta vc coloca os arquivos setup.py (instalador do seu projeto), README, etc
<xNetoXMartinsx> e todos os módulos eu coloco dentro daquela mesma pasta?
<nosklo> xNetoXMartinsx: dai vc cria uma pasta NetoChat/netochat que é o pacote python do seu projeto
<nosklo> xNetoXMartinsx: dentro vc cria um arquivo NetoChat/netochat/__init__.py vazio
<nosklo> xNetoXMartinsx: dai vc pode criar outras subpastas, como NetoChat/netochat/comunica.py, NetoChat/netochat/tela.py NetoChat/netochat/eventos/som.py NetoChat/netochat/eventos/email.py
<nosklo> xNetoXMartinsx: crie um NetoChat/netochat/principal.py que vai ser o seu programa principal, dentro de uma funcao def main()
<nosklo> xNetoXMartinsx: dai vc gera um NetoChat/bin/nchat.py que dá um “from netochat.principal import main ; main()”
<nosklo> xNetoXMartinsx: se dentro de principal.py vc precisa de comunica.py vc pode fazer: from netochat import comunica
<nosklo> xNetoXMartinsx: from netochat.eventos import som
<nosklo> xNetoXMartinsx: crie tbm um NetoChat/netochat/tests e ponha seus testes la
<xNetoXMartinsx> nosklo, cara, você me ensinou tudo que eu tava querendo saber
<xNetoXMartinsx> kkkkkkkkkkkk
<nosklo> xNetoXMartinsx: a documentação vc poe em NetoChat/doc
<xNetoXMartinsx> nosklo, você é o cara mano!
<xNetoXMartinsx> nosklo, eu vou é copiar essa conversa e salvar!!!
<xNetoXMartinsx> kkkkkkkkkkkkkkkkkkk
<nosklo> xNetoXMartinsx: vou postá-la no meu blog
<nosklo> xNetoXMartinsx: agora
<nosklo> xNetoXMartinsx: pythonlog.wordpress.com
<nosklo> xNetoXMartinsx: qdo lançar seu programa, copie ele para NetoChat-1.0
<nosklo> xNetoXMartinsx: se compactar, fica NetoChat-1.0.tar.gz

Afinal, tem um motivo pelo qual todo livro de Python que se preze, no primeiro capítulo, coloca uma cláusula desta forma:

if __name__ == '__main__':
   # do stuff

Isto permite a execução desta parte do módulo como um script, mas impede a execução caso o módulo seja importado por outro módulo. Todo script pode no futuro ser importado por outro módulo, e como o autor do módulo parece não querer que o código dentro do bloco “if” seja executado neste caso, faz sentido colocar tudo que não faz parte da inicialização do próprio módulo dentro de uma cláusula destas.

__name__ é uma variável definida automaticamente pelo interpretador, que recebe o valor '__main__' quando o script atual é o que foi iniciado no interpretador. Para scripts importados, __name__ é o nome de importação do script. Essa diferença permite escrever código que execute condicionado ao módulo ter sido importado ou executado.

Importar um módulo deve fazer no máximo estas coisas:

• Importar outros módulos ou globais
• Atribuir valores constantes a variáveis
• Adicionar novas funções usando a cláusula def
• Adicionar novas classes usando a cláusula class
• Fluxo de controle que pode controlar partes condicionais do módulo para tratar erros ou versões específicas de certas plataformas para os casos acima.

Qualquer outro tipo de lógica executada direto no corpo de um módulo python (código que roda automaticamente durante imports) é tratado com suspeita e provavelmente está no lugar errado.

É um absurdo construir um sistema que se inicia ou se configura baseado em efeitos colaterais da importação de módulos. Você perde o controle de quando o código será executado. Ferramentas de inspeção automática de código, geração de documentação e de testes muitas vezes precisam importar o módulo para efetuar suas tarefas, e isto causa efeitos indesejados.

Será que eu tenho que fazer uma ferramenta automática de publicação? Algo simples, pegaria as novidades de RSSs que eu gosto e enviaria em forma de post para meu blog. O chato de uma ferramenta é que eu teria que lembrar de rodar. Deveria ter isso pronto, não?

<NandoFlorestan> socorro, o Python não tem uma encoding de que preciso. self._current_txt = pay.decode(charset, ‘ignore’)
<NandoFlorestan> LookupError: unknown encoding: ansi_x3.110-1983
<nosklo> NandoFlorestan, crie seu proprio encoding e registre-o
<NandoFlorestan> heheheheh. Talvez eu consiga usar o iconv
<vambboy nosklo, como criar um coding?
<vambboy> num sabia q era possível
<nosklo> vambboy, faca uma funcao pra encodificar, uma pra decodificar, uma classe que encodifique e decodifique incrementalmente, e subclasses para escrita e leitura de streams
<NandoFlorestan> vambboy, tá interessado? Quer fazer pra mim? Implementa aí o tal ansi_x3.110-1983…
<nosklo> vambboy, em seguida registre estas funcoes usando codecs.register()
<NandoFlorestan O nosklo é uma enciclopédia
<nosklo> eu ja fiz um encoding pra 13375p34k
<vambboy>  é o eu diga, ele nasceu com sangue de cobra
<vambboy> e cabra era o python
<vambboy> kkkkkk
<NandoFlorestan> “é o eu diga”?
<NandoFlorestan> cabra?
<vambboy> foi mal
<vambboy> era cobra
<nosklo> precisamos de um encoding pra decodificar as frases do vambboy
<NandoFlorestan> só por causa disso, meu próximo software em python vai se chamar CABRÓN
<vambboy nosklo, c te ofendi desculpa
<nosklo> ofendeu nada, eu nem entendi o q vc falou
<vambboy> kkkkkkkkkkkkk
* NandoFlorestan vê que vambboy está na berlinda…
<NandoFlorestan> cabra + python = cabrón
<nosklo> NandoFlorestan, tem alguma documentação deste encoding? não é mto difícil implementar encodings.
<NandoFlorestan> Maldito seja o feadapot que resolveu me mandar email com essa desgraça…
* NandoFlorestan não quer ficar fazendo encodings, saco
<vambboy> num intendi direito o q o NandoFlorestan quer fazer
<NandoFlorestan> vambboy, existe uma encoding chamada ansi_x3.110-1983
<NandoFlorestan> se você tentar usá-la no Python, dá erro
<NandoFlorestan> Ele não a conhece
<vambboy> nunca vi
<NandoFlorestan> Então eu vou ter que implementá-la e registrá-la
<NandoFlorestan> Tou a fim de delegar para o iconv que todo linux tem
<vambboy> onde é aplicada
<NandoFlorestan> também nunca vi
<vambboy> em q tipos d caracteres?
<NandoFlorestan> não sei, mas é exótica mesmo
* NandoFlorestan não decodificou e portanto não leu o email
<vambboy> ah tah
<vambboy> e quem diabos mandaria um email assim?
<vambboy> um agente secreto?
<NandoFlorestan> heheheh
<NandoFlorestan> vai ajudar ou só zoar?
<vambboy> bem
<vambboy> procurarei algo
* NandoFlorestan saca seu editor de textos colaborativo
<NandoFlorestan> …como chamava mesmo?
<nosklo> NandoFlorestan, se vc tiver documentação do encoding fica fácil, delegar pro iconv sux
<nosklo> hummmmmmmm
<NandoFlorestan> gobby
* nosklo começa a escrever um encoding para iconv x.decode(‘iconv:XXXX’) onde XXXX é passado para o iconv
<nosklo> mas relaxe, mto breve vc poderá usar qq codec suportado pelo iconv
<NandoFlorestan>
* nosklo está modificando o código q já tinha
* NandoFlorestan pensa num recurso: dar um iconv –list e registrar todos os codecs que Python não tenha
<nosklo> besteira
<nosklo> NandoFlorestan, x.decode(‘iconv:xxxx’)
<nosklo> NandoFlorestan, vc só roda o subprocesso iconv se precisar usar o codec
<vambboy> em q módulo se encontra o iconv?
<nosklo> vambboy, iconv é um aplicativo escrito em C
* NandoFlorestan testa
<nosklo> NandoFlorestan, hah, teste depois q eu mandar o codigo
<NandoFlorestan nosklo, não faz ‘iconv:xxx’
<NandoFlorestan> faz com o nome correto da encoding: ansi_x3.110-1983
<nosklo> NandoFlorestan, entao, isso q estou falando
<nosklo> NandoFlorestan, no seu caso vc vai usar, suastring.decode(‘iconv:ansi_x3.110-1983′)
<NandoFlorestan> mas sem prefixo iconv:
<NandoFlorestan> tá, mas eu vou mudar seu código pra tirar o prefixo
<nosklo> NandoFlorestan, bom ok
<NandoFlorestan> porque isso tá chegando de um email e eu não quero ficar lidando com exceções
<nosklo> NandoFlorestan, a minha idéia é não precisar saber de antemão quais os codecs que tem disponíveis, pq senão eu tenho que chamar o iconv mesmo se não for precisar dele
<NandoFlorestan> Faz sentido, mas eu acho que precisamos dos 2 modos de operação então
<NandoFlorestan nosklo, o comando é iconv -f utf8 -t ansi_x3.110-1983 -c
<NandoFlorestan> -f é from, -t é to, -c é pra omitir caracteres inválidos.
<nosklo> o -c será dado se vc passar x.decode(‘iconv:xxx’, errors=’ignore’)
<NandoFlorestan> isso isso
<nosklo> pronto, .decode e .encode já está funcionando
<nosklo> agora vou fazer codecs.open(‘arq’, encoding=’iconv:xxxx’)
<vambboy> quando terminarem manda um paste aí, quero estudar o código
<NandoFlorestan nosklo, http://pypi.python.org/pypi/iconv/1.0
<nosklo> argh
<nosklo> ja existe
* nosklo deleta tudo
<NandoFlorestan> caaalma
<NandoFlorestan> tem que ver se é bom
<nosklo> testa aí então, vou comer alguma coisa
<NandoFlorestan> nosklo, import iconv já dá pau
<NandoFlorestan> nosklo, essa porcaria de módulo iconv não funfa porque foi feito em C em 2005
<nosklo> NandoFlorestan, okay, continuando

(… alguns minutos depois …)

<nosklo> bom, tá funcioando
<nosklo> funcionando
<nosklo> NandoFlorestan, vambboy, huahauhauahuaha
<nosklo> >>> u’teste’.encode(‘iconv:CP284′)
<nosklo> ‘\xa3\x85\xa2\xa3\x85′
<nosklo> >>> _.decode(‘iconv:CP284′)
<nosklo> u’teste’
<NandoFlorestan> nosklo, cadê?
<NandoFlorestan> cá… dê !!! dê cá!
<NandoFlorestan nosklo… por favor?
<nosklo> NandoFlorestan, opa… ja vai, colando…
<vambboy> nosklo, tô vuando isso quer dizer que funcionou?
<nosklo> NandoFlorestan, vambboy, tá ai http://dpaste.com/5377/
<nosklo> só dá um import estearquivo
<nosklo> e pronto
<nosklo> vc pode usar qq codec do iconv
<nosklo> no codecs.open etc

<durfos> Hai ! raça
<durfos> podem me dar um help para entender a licença do python
<durfos> ?
<durfos> o povo lah do escritorio quer usar python pra fazer um software pra vender .. tem algum problema ?
<durfos> e outra eles num querem enviar o codigo soh os bytecode pro cliente
<Khaoz> durfos: dando uma olhada por cima da licensa, parece que você pode fazer isso sim.
<nosklo> não que enviar só o bytecode tenha alguma utilidade
<nosklo> durfos, não tem binário, o python é compilado para bytecode, e este bytecode pode ser facilmente decompilado
<durfos> a certo eu não sabia q era tão fácil assim
<nosklo> durfos, em qualquer linguagem decompilação é muito fácil. Tentar esconder o código hoje em dia é besteira
<durfos> o pessoal com quem trabalho .. esta afim de fazer um aplicativo comercial
<nosklo> durfos, Aplicativos livres e de código aberto podem ser vendidos comercialmente
<durfos> e usar alguns módulos inclusive readline que é GPL ..
<durfos> certo entendi .. vc tem razão
<nosklo> durfos, GPL tem uma cláusula que permite a venda do programa
<nosklo> GPL nunca restringiu venda
<durfos> tem ?
<nosklo> claro!
<durfos> entendi
<durfos> é verdade .. tem q enviar o source junto né .. essa é a clausula e manter os nome dos autores
<nosklo> se for GPL, a única coisa que você não pode fazer é impedir quem comprar o seu programa de distribuí-lo
<nosklo> o source você tem que mandar de qq jeito, afinal é em python
<durfos> é verdade faz todo sentido .. não vale a pena mesmo pra gente .. os pode fazer é só enviar os pyc bytecode ..
<durfos> no caso de vender a app
<nosklo> qdo vc desenvolve um software, se vc não usar nenhuma lib que te obrigue a adotar alguma licença, você pode criar sua própria licença dizendo que o que vc quer que o cara possa fazer com o programa
<durfos> mesmo assim nada impede da decompialacão
<nosklo> mandar só os bytecode não vale a pena, não faça isso
<durfos> pq ?
<nosklo> os bytecodes são específicos da versão do python que você os criou, e só rodam nesta versão e plataforma
<nosklo> e você não ganha nada mandando só o bytecode
<nosklo> não te dá nenhuma vantagem de obscuridade
<durfos> tá .. mas eu ralei pra fazer meu software, um cara pega .. e vende ele sem nenhum esforço
<nosklo> para impedir isso você usa uma licença
<nosklo> mandar em bytecode não segura o cara, o que segura, legalmente, é a licença do software
<durfos> tá mas ae eu vou precisar escrever do zero tudo em C ?
<nosklo> não tem nada a ver
<durfos> eu posso colocar outra licença sobre o python ?
<nosklo> você pode escrever em qualquer linguagem
<nosklo> a licença do python não influencia em nada na licença do software em python que você escreve
<nosklo> para distribuir o python você segue a licença do python
<nosklo> mas para distribuir seu programa você pode criar a forma de licenciamento
<durfos> a tá no caso a licença do python é usada para distribuir o source do interpretador é isso ?
<durfos> e para distribuir meu código eu uso outra licença
<nosklo> exatamente. Você pode até distribuir seu código sem um interpretador, daí o cara pode pegar qualquer interpretador e rodar, Cpython, activepython, jython, Pypy, IronPython
<durfos> mas seu usar no caso um modulo q tem licença GPL digamos o SQLObject
<nosklo> aí para distribuir código que usa esta lib você tem que seguir os termos da licença da lib
<nosklo> ou seja seu código teria q ser GPL
<durfos> entendeu .. eu vou ter q dar parte do meu source .. em GLP não vou poder aplicar minha licença em cima
<nosklo> exatamente. Porém mesmo sendo GPL você pode vender. Só que o cara que comprou vai poder redistribuir a vontade
<nosklo> agora que você entendeu: vou te contar o canal para desenvolvimento opensource comercial
<nosklo> -> venda de serviço
<nosklo> você dá o software pro seu cliente, mas vende os serviços de instalação, customização, treinamento, manutenção
<nosklo> o software é GPL mas o serviço não
<durfos> é isso eu já manjei
<durfos> trabalho com algo assim já
<nosklo> o cliente vai querer que você faça o serviço pq foi vc que fez o programa, ninguém melhor q vc para mexer nele
<durfos> minha duvida era com o bytecode seu eu posso colocar licença nele
<nosklo> esquece bytecode
<nosklo> bytecode é besteira, distribui o fonte de qq forma
<durfos> entendi
<nosklo> se não usar nenhuma lib com licença viral, você pode sim distribuir seu código em qq licença.  A licença do python não impede isso
<durfos> é, mas a sqlobject é viral
<durfos> ela é GPL
<nosklo> então pra usar sqlobject você tem que distribuir seu código em GPL também. Não tem alternativa
<nosklo> pq vc não usa sqlalchemy? é bem melhor!
<durfos> aé melhor ?
<nosklo> com certeza!
<durfos> vc trabalho com python a quanto tempo .. ?
<nosklo> profissionalmente tem uns 3 anos
<durfos> e vc distribui seu source só pro cliente q vc vende o software certo ?
<durfos> ou melhor vende o serviço
<nosklo> bom, eu sou contratado por uma empresa, o software que eu desenvolvo pertence a empresa, ela licencia como quiser
<nosklo> geralmente nao licencia
<nosklo> usa internamente e pronto
<nosklo> como o software nao vai ser distribuido, nao precisa de licença
<durfos> entendi
<durfos> eu fui pro sqlobject pq eu achei ele rápido e intuitivo
<durfos> bom . na verdade foi o único q eu experimentei
<nosklo> bom, sqlalchemy é mto melhor
<nosklo> sqlobject mistura a declaração da classe com a da tabela
<nosklo> o sqlalchemy separa isso
<nosklo> de forma que você pode vincular qualquer query à Classe
<nosklo> isso é mto útil
<nosklo> mapear classes a queries
<nosklo> mas tem outras diferenças
<durfos> hum .. e desempenho ?
<nosklo> coisas como polimorfismo, herança multipla, versionamento de registro, ordenação automática de relacionamento, que eu acho que não tem no sqlobject
<durfos> caraka versionamento de registro !? polimorfismo ?
<durfos> me convenceu !
<nosklo> se vc quiser for usar o sqlalchemy, criei o canal #sqlalchemy-br aqui na freenode a algum tempo e estou sempre lá
<durfos> blz !
<nosklo> e a licença do sqlalchemy é MIT
<durfos> vou passar lá com certeza
<nosklo> <durfos> e vc distribui seu source só pro cliente q vc vende o software certo ?
<nosklo> <durfos> ou melhor vende o serviço
<durfos> legal !
<nosklo> sim, é assim que eu faria
<nosklo> depende do source é claro
<nosklo> posso distribuir para todos tbm dependendo do que for, pode me ajudar a conseguir mais clientes se eu divulgar o código
<durfos> hum interessante
<nosklo> e se colocar o código em GPL posso conseguir ajuda de outros programadores gratuitamente
<nosklo> tendo assim um código de qualidade maior com menos custo e esforço
<nosklo> do que fazendo tudo sozinho
<durfos> é eu sou mais fã das licenças do tipo BSD
<durfos> é vc tem razão, e as licenças tem os dois gumes né
<nosklo> o problema é que o cara pega seu código, modifica, e licencia na licença dele e você não pega as modificações
<nosklo> eu sou a favor de ganhar dinheiro em troca de trabalho
<nosklo> não vendendo licença
<nosklo> por isso prefiro vender serviço
<durfos> é o estilo que a Red Hat adotou e supreendeu todo mundo em 2004
<nosklo> sou contra o cara que faz um programa uma vez e depois quer ganhar dinheiro com ele para sempre
<nosklo> geralmente faço o programa sob encomenda, então recebo uma vez e pronto, o programa vai pra GPL. Eu já recebi.
<nosklo> Se quiser continuar recebendo tenho que continuar trabalhando.
<nosklo> Então vendo serviço…
<durfos> depende do programa q vc vai fazer
<durfos> na verdade depende do jeito q cada um quer ganhar dinheiro é gosto
<nosklo> não acho legal eu ir recebendo por “cópias do programa”, sem trabalhar deitado na minha cama
<durfos> é gosto né
<nosklo> não, é ética
<durfos> mas digamos q vc faz um programa legal pacas pra um cliente seu
<durfos> e ele te paga beeeeeeeem
<durfos> ae vc vai lá e licencia .. GPL
<durfos> um cliente q ia te pagar mais ainda por ele .. pega o source . e usa e pronto, vc não sentirá mal ?
<durfos> tipo poderia ter ganhado bem mais ?
<nosklo> não
<nosklo> eu já recebi pelo serviço que eu fiz
<nosklo> recebi o tanto que o serviço vale
<nosklo> para receber mais, éticamente eu tenho que trabalhar mais
<nosklo> o outro cliente vai acabar me chamando pra configurar/customizar pra ele pq fui eu q fiz o programa
<nosklo> daí eu ganho mais, porém por ter trabalhado mais
<durfos> é interessante
<nosklo> o primeiro cara já me pagou, o programa vai pra GPL, todo mundo pode usar e ajudar a melhorar ainda mais o programa, que é legal pacas
<nosklo> o resultado final é melhor para todos
<nosklo> se eu fechar, meu programa não vai ser tão “legal pacas” assim
<durfos>
<durfos> mas e se o cliente comprar teu source ?
<nosklo> a empresa que trabalho atualmente é assim, escrevo o source mas ele não é meu
<nosklo> recebo pelo meu serviço do mesmo jeito
<nosklo> uso um monte de coisas GPL então se a empresa quiser distribuir vai ter q licenciar em GPL
<durfos> mas vc não pode licenciar em GPL
<nosklo> poderia
<nosklo> não posso pq ele não é meu
<durfos> exatamente
<nosklo> mas poderia licenciar no que eu quisesse, pq não vou distribuir
<nosklo> a licença só serve qdo vc vai distribuir
<nosklo> se vc vai usar vc mesmo o programa, não importa a licença
<durfos> tá eu vou vender pra várias empresas meu prgrama .. e não vou enviar o source ? se eles pedirem eu tenho q dar
<durfos> isso é certo
<nosklo> você tem que mandar o source de qualquer jeito
<nosklo> pra eles poderem rodar o programa, precisam do source
<nosklo> python funciona assim
<nosklo> a questão é como você vai licenciar o source para entregar para eles
<nosklo> no meu caso atual o source é deles
<durfos> é ae eu posso licenciar pra eles sobre a minha licença ..
<nosklo> eu não posso sair e levar pra outra empresa, eu teria que começar de novo
<durfos> e no caso vou ter q tirar o sql object da jogada
<nosklo> ou então, licencia em GPL
<nosklo> você tem que entregar o source mesmo
<nosklo> qualquer q seja a licença
<durfos> maravilha entendi perfeitamente
<durfos> vlw pela ajuda nosklo!
<nosklo> durfos, “licenciamento” é uma lei restritiva artificial que serve para estimular a criatividade e o desenvolvimento
<nosklo> durfos, porém ela acaba cumprindo mal o seu papel, pq com licenças restritivas todo mundo fica reescrevendo a mesma coisa de forma inferior
<nosklo> durfos, quantos programas de controle de estoque vc já viu?
<nosklo> heheheh
<durfos> rsrs
<durfos> miilhoes hein ! rs
<nosklo> se todo mundo programasse pra 5 ou 6 programas de controle de estoque BONS, GPL
<nosklo> ia ser um estimulo muito maior ao desenvolvimento e criatividade
<nosklo> do que nego que acaba de aprender a programar, ficar querendo fazer um programa só de controle de estoque e vender ele pra todo mundo
<durfos> rsrs
<nosklo> então a lei de direito autoral está furada, ela não está servindo para o que deveria, quem deveria ganhar não está ganhando.
<nosklo> a GPL é uma tentativa de consertar isso
<nosklo> pq acontece que existem 100000 programas de cont. estoque ruins, você faz mais um, e acaba tendo que vender pra meia duzia de gatos pingados por 10 reais
<nosklo> ao inves ter uns poucos programas, porem bons e completos, e você vender customizações e serviços em cima deles
<durfos> é infelizmente isso numca vai mudar né
<nosklo> quem ganha com essa lei e licenciamento são só gigantes como Corel, Microsoft…
<nosklo> nós meros mortais ganhamos mixaria
<nosklo> ganhamos mais é trabalhando mesmo

<NandoFlorestan> nosklo, concordo tanto com as coisas que você falou agora que é como se eu fosse 50
<NandoFlorestan> …50% mais inteligente e as tivesse dito eu mesmo.