jump to navigation

Três Pulinhos no Tablet Acer Iconia One 7 2015/06/06

Posted by gsavix in computador portátil, Computadores, debug android, dedução, Doc, Memorando, open source computer, organização do conhecimento, organização do raciocínio dedutivo, sistema hipotético dedutivo, Sistemas Computacionais.
Tags: , , , ,
add a comment

Se você também é mais um dos milhares de consumidores que comprou um tablet acer esses vendidos em “Baciada” olhou a caixinha e viu escrito intel inside olhou que é versão 4.4.2 LollyPop, viu que tem bluetooth, 8 gigabytes de memória e decidiu comprar o Acer B1-730.

Agora chegou em casa viu que assim como outros equipamentos essa galera da acer também instalou vários aplicativos úteis e vários inúteis, chegou a conclusão
que quer desintalar os inúteis, tentou desinstalar e não conseguiu.

Aí sentiu aquela sensação, “xi vou ter que engolir!”

Ah não! essa não! me disseram que o Android era um sistema operacional livre!

Após uma rápida pesquisa na internet descobriu que para excluir aplicações consideradas inúteis você precisa assumir poderes de super-usuário ou superusuário ou mesmo super usuário.

Descobriu que no linux normal você usa: sudo passwd e basta informar a nova senha do super user root.

Ah! simples! vamos nessa!

Pegou o cabo usb conectou na seu computador com o sistema operacional do bill gates e recebeu uma mensagem dizendo que seu equipamento foi reconhecido pelo windows e que você deve colocar o seu recém adquirido tablet android 4.4.2 no modo “usb debug” modo esse que pode ser encontrado dentro
do menu desenvolvedor.

Ora bolas! toda essa conversa para explicar que o menu do desenvolvedor fica oculto!

Putz! como acessar então? Simples! siga essas instruções gentilmente colocadas no site da acer do reino unido e você conseguira finalmente acessar o menu desenvolvedor para colocar a usb em modo debug!

Ah! façam-me o favor né! Não basta terem configurado meu tablet como idioma padrão francês ainda mais essa receitinha dos 7 tapinhas no menu “sobre meu tablet”

Enable Developer Options on Android 4.2 and later

How do I enter the Developer options menu on my Android tablet or phone running 4.2 or later?

The Developer options menu will give you access to USB debugging mode and other developer options.

Use the following steps to to gain access to the Developer options menu.

Go to Settings.
Scroll down and select the About tablet or About phone option.
Scroll down to the Build number and tap it seven times.
You will see a confirmation message and the Developer options menu will appear on the left.

Anúncios

Tributo para a Linguística e Chomsky 2013/04/28

Posted by gsavix in Computadores, Conhecimento, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, publicador documentação, Sistemas Computacionais, Sistemas de Gestão da Produção, sociologia do conhecimento, Soft.
add a comment

Como traduzir em palavras para alguém que me pergunta:

O que a Linguística tem a ver com ciência da Computação?

Realmente não é intuitivo explicar que na Universidade de São Paulo existe a Faculdade de Filosofia Letras e Ciências Humanas que possui um Departamento de Linguística que foi criado nos anos 198X.

Mas acontece que este departamento entre outros conhecimentos fundamentais para qualquer pessoa que pretenda entender ou pouco mais sobre ciência, pesquisa e ensino, também cuida da Fonologia, da Morfologia Semântica e Sintática, da Semiologia e diversas outras disciplinas que são vitais para auxiliar na compreensão do pensamento, da transmissão e recepção de mensagens, a desconstrução de modelos lógicos semânticos ou sintáticos; resumindo algo a ver com lógica sem a qual não é possivel compreender, aprender nem transmitir conhecimento.

Desde a graduação em linguística quando passei a saber da existência de Noam Chomski, Ferdinand de Saussire, Roland Barthes   entre outros, o ponto de vista sobre linguagens de computação que até então eu usava para construir aplicações e sistemas, como Cobol, RPG, Fortran, Assembler, Algol, REXX passaram a compor uma outra dimensão.

Como entender a lógica aplicada na linguagem humana, seja ela escrita, falada, representada em uma peça teatral, uma novela apresentada em capítulos, um folhetim ou um filme que tem a magia de transformar uma sala de cinema em outro lugar?

Como decifrar o conhecimento existente nessa lógica de apresentar algo?

Como a propaganda consegue usar e abusar desse conhecimento passando ao largo da lei, da ética ou de qualquer barreira cultural?

Logo nas primeiras aulas para minha frustração um eminente professor do departamento desmontou minhas pretensões de fazer qualquer paralelo entre a linguística que em sua visão deveria ser usada apenas para compreender a linguagem humana e não serviria para captar ou compreender ou modelar a linguagem usada nos computadores.

Demorei mais de cinco anos até encontrar documentação de ponta sobre o conceito das linguagens simbólicas como a linguagem assembler usada para abstrair qualquer coisa, macros que permitiam apenas com algumas instruções e parâmetros produzir “objetos” que poderiam ser qualquer coisa ou classe. Ainda no final dos anos 80 tomei contato com a linguagem C++ orientada a objeto que nos permitia modelar classes, hereditariedade, polimorfismo, métodos, acoplamentos entre outras propriedades ou atributos.

Isso me permitiu compreender toda a gramática sintática e semântica que os engenheiros projetistas de linguagens e não sómente codificadores de sistema precisaram construir para permitir que através da linguagem C++ fosse possivel escrever uma solução para uma aplicação de computador e que esta poderia com muito menor esforço do que o requerido pelos programas em linguagem assembler.

Assim conheci a linguagem SmallTalk que já existia desde o pós segunda-guerra mas que para nós que escreviámos aplicações comerciais, financeiras ou muito triviais parecia não utilizável.

Quando passei a me interessar mais pela estrutura de uma aplicação para entender os pontos que não apresentam uma boa performance e são considerados como “gargalos” pois impedem maximizar recursos de computação, transmissão ou recepção (hoje usando a internet), processos sincronos, assíncronos, recuperação semântica ou fonética percebi que as disciplinas que lidam com a lógica, matemática, modelos gramaticais e semânticos passam a ter uma importância que pode definir se uma aplicação será um sucesso comercial e econômico gerando ganhos para as empresas que a utilizam.

Logo pude encontrar os conectores de aplicações ou API que permitem a conexão de diferentes aplicações e funcionalidades permitindo o aproveitamento de aplicações estáveis mas que não possuiam a capacidade de interagir com as novas gerações de aplicativos.

Faz algum tempo já encontrei alguns artigos que permitem ilustrar minhas desconfianças sobre usar intensamente a linguística para criar, modelar, documentar procedimentos executados por humanos ou não chamados workflow. Um certo tipo de sequênciamento de procedimentos permitindo mapear, custear, modificar recursos alocados a cada etapa do procedimento.

Muitas novas linguagens como por exemplo HTML, XML, JSON, JAVA, , WSDL, PL/SQL para os bancos de dados, Perl, PHP, Python, BPEL, BPMN, WS-BPEL (usada para especificar serviços na web), Máxima e WxMáxima escritos em Lisp que permitem a modelagem matemática muito rápida e principalmente sendo software livre GPL

Apresentarei dentro de semanas uma tradução que demonstra esses conceitos iniciais, a partir de uma tradução de um artigo de Aaron Maxwell do sítio eletrônico url: http://redsymbol.net/articles/svg-markup-chomsky/ que tão bem ilustra isso.

Enquanto isso apresento o artigo original em inglês:

SVG, Markup Languages and the Chomsky Hierarchy

A fascinating correspondence between markup languages and the theory of computation

Note: This is an incomplete draft.

Software development sometimes seems divorced from the theory of computer science. Certainly being good with math does not automatically make one a great coder, and vice versa; some different skills and personality traits are required.

Deep down, however, there are certainly places where the two worlds intersect. Some friends and myself came across one recently, at the intersection of two roads: gritty, practical XML markup languages, and the Chomsky Language hierarchy.

SVG is such a markup language. It’s an XML specification of 2D vector graphic images, which can be rendered directly or converted to other image file formats.

simple.svg svg source

<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" 
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100" height="60"
     xmlns="http://www.w3.org/2000/svg">
  <rect fill="green" x="15" y="15" width="70" height="30"/>
  <rect fill="red" x="20" y="20" width="60" height="20"/>
</svg>

SVG provides a rich set of primitives and high level features for describing two-dimensional graphics, including operations for styling, object grouping and transformations, and for incorporating text and bitmap images. In addition, it is an open web standard. It’s an interesting file format for what it does.

Let’s switch topics a moment to the language hierarchy. In the mid-20th century, Noam Chomsky famously outlined a ranking of formal languages based on their expressive power. Here, “formal” means “defineable using the tools of computer science and mathematics.” In the end, every general-purpose and specialized programming language is formal in this sense, even if the details of creating the formal description can get messy.

Chomsky’s original hierarchy had at least four distinctions, and several more refined distinctions usefully exist. Here, we are concerned with two of those categories: regular languages and context-free languages.

A language, in this context, is just a set of strings. That’s all. It can be an infinite set, and in fact, all useful programming languages I know of are infinite. Imagine all possible valid Java programs. That is a set of strings, and hence a language. Now imagine all possible regular expressions. That, too, is a set of strings, and a language. (The word “language” is overloaded a bit, which could confuse us if we allow it. We’ll try to dodge that.)

A language can be categorized depending on its expressive power. Two such categories are called “regular” and “context-free”. The definitions are quite precise: a language is regular if there exists some finite state machine that accepts all strings in the language and rejects all strings outside of it. And a language is context-free if there exists some context-free grammar that accepts all strings in that language, and rejects those outside of it.

You may be familiar with both finite state machines (FSMs) and context free grammars (CFGs). They are simply mathematical constructs that can be used to define sets of strings. In case you don’t recall or never learned, an important fact is that not all languages can be described by a FSM. In other words, some languages are regular, and some are not. Similarly, some languages are context-free (can be described by a CFG), and are not. However, all regular languages are also context-free languages, but not vice versa.

In other words, the set of context-free languages is a strict superset of the set of all regular languages. For this reason, we say that context-free languages have more expressive power than regular languages.

Now, how does this relate to markup languages? Well, XML, and some XML markup languages like SVG and XHTML, are all context free. You cannot create a finite state machine that will correctly discriminate all possible XML (or SVG or XHTML) documents.

However, every context-free language has subsets that are regular. Sometimes this is useful. Let’s start with a contrived example: minimal HTML documents that just contain lists. Consider exhibit A:

<html>
  <body>
    <ul>
      <li>Hello</li>
      <li>Handsome</li>
      <li>Programmer</li>
    </ul>
    <ul>
      <li>Another</li>
      <li>List</li>
    </ul>
  </body>
</html>

This specimin – a multi-line string – is from a language that is a limited subset of XHTML. Namely, those whose body contains only unordered lists, and whose list items contain simple text. It is a regular language; you can craft a FSM that accepts only this language. Now, you may or may not be conversant in building state machines. Regardless, we can just use regular expressions instead: as theorems in any thorough automata textbook will show, if and only if a language is regular, there exists some regular expression that accepts it (and rejects strings not in the language). So one regular expression for Exhibit A is:

"<html><body>" ("<ul>" ("<li>" text "</li>")* "</ul>")* "</body></html>"

This regular expression will only accept these simple-list HTML documents. Well, fine. But what if you need to work with documents like this:

<html>
  <body>
    <ul>
      <li>Programmers</li>
      <li>are</li>
      <li>
        <ul>
         <li>Handsome</li>
         <li>Charming</li>
         <li>Happy</li>
        </ul>
      </li>
    </ul>
    <ul>
      <li>Random</li>
      <li>Words</li>
    </ul>
  </body>
</html>

Here, there is a nested list, which is definitely not accepted by the regular expression above. Can you write a regular expression that will? Yes, but it would be a little messy, and that’s if you limit it to a single level of nesting. Nest deeper, and the regex explodes quickly. It turns out that no regular expression will match list nested to arbitrary depth.

However, a context free grammar that does so is pretty simple:

  HTML -> "<html><body>" UL* "</body></html>"
  UL -> "<ul>" LI* "</ul>"
  LI -> "<li>" ITEM "</li>"
  ITEM -> [char]* | UL

It is probably uncommon that you will encounter the need for infinitely nested HTML lists. This is an intentionally simple example, to make the concept easier to see. Now let’s look at something more complex and practical.

Here is a histogram, whose source is an SVG document:

http://static.redsymbol.net/articles/svg-markup-chomsky/img/Black_cherry_tree_histogram.svg svg source

(credit)

If you look at the source, you will see that it mainly consists of simple elements, defining lines, text and rectangles. Now, imagine all possible SVG documents that render histograms. Assume they are basic histograms, of the same form of the example here, devoid of unnecessary decorations like fractal outlines or anything weird like that.

That set of all SVG documents that render histograms is a set of strings – a language. Quiz time: is this language regular?

Yes, it turns out. Structurally, it is simply “START BAR* END”, where START is a header for the SVG document, each BAR is an SVG snippet that renders one of the bars, and END is a closing tag. (Actually, I’m lazily omitting elements to display the axes, tick marks, labels, etc. No matter; the end result is the same.) mkhist.py is a short python program that generates such histograms:

#!/usr/bin/env python
'''
_start_ _bar_* _end_

'''

_start = '''<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" version="1.1"
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">
  <desc>Histogram</desc>

  <!-- Begin data plots -->
'''

_end = '</svg>\n'

def _bar(n, v):
    s = '  <!-- Histogram bar #%d (value: %d) -->\n' % (n, v)
    x = 10 + 20 * n
    h = v * 10
    s += '  <rect fill="red" x="%d" y="5" ' \
         'width="10" height="%d"/>\n' % (x, h)
    return s

data = [1, 5, 7, 3, 12, 4]

svg = _start
for n, v in enumerate(data):
    svg += _bar(n, v)
svg += _end

print svg

The data being plotted is hardcoded near the end. Using those values, mkhist.py will generate a histogram like this:

http://static.redsymbol.net/articles/svg-markup-chomsky/img/histogram.svg svg source

<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" version="1.1"
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">
  <desc>Histogram</desc>

  <!-- Begin data plots -->
  <!-- Histogram bar #0 (value: 1) -->
  <rect fill="red" x="10" y="5" width="10" height="10"/>
  <!-- Histogram bar #1 (value: 5) -->
  <rect fill="red" x="30" y="5" width="10" height="50"/>
  <!-- Histogram bar #2 (value: 7) -->
  <rect fill="red" x="50" y="5" width="10" height="70"/>
  <!-- Histogram bar #3 (value: 3) -->
  <rect fill="red" x="70" y="5" width="10" height="30"/>
  <!-- Histogram bar #4 (value: 12) -->
  <rect fill="red" x="90" y="5" width="10" height="120"/>
  <!-- Histogram bar #5 (value: 4) -->
  <rect fill="red" x="110" y="5" width="10" height="40"/>
</svg>

With some small modifications, one can add the useful decorations (axes, labels, etc.) It’s a little remarkable, when you think about it, that the universe of all possible histogram plots can be described by a reasonably simple state machine.

Now, can you think of examples of other “image languages” – sets of SVG documents – that are not regular?

One example: sets of images with some kind of bilateral symmetry — reminiscent of the classic context-free language example LCFG = {anbn | n > 0}. Perhaps more commonly, any image representing data with some kind of nested tree structure will not be regular either. Think organizational charts, electronic circuit diagrams, and graphical representations of parse trees.

(By the way, don’t fall into the trap of defining an overly permissive regular language, and believing that adequately describes your context free language. When crafting a construct to define a language, whether that construct be an FSM, regular expression, or CFG, the strings that the construct rejects are just as important as those it accepts. Let’s define a language named Lall by a regex C*, where C is any unicode character. Any context-free language will be a subset of L; that doesn’t mean L is in any way useful to you.)

Let’s examine one of these image classes that must be described by a context free language. Imagine a simple integer arithmetic language, using prefix notation. Its operators – consisting of *,+ and - – always take exactly two arguments, which can be either an integer, or another expression (surrounded by parentheses). So you will have expressions like (+ 2 3)(* 7 (+ 2 4)), and (+ (* (+ 2 3) 4) (- 7 2)) as members of this language.

Consider a specific expression: (* (+ 2 3) (- 7 (* 8 9))). Here is the syntax parse tree for it:

parsetree.svg svg source

In fact, this figure is an SVG image generated by an analogue of the histogram-writing script above. We’ll see that script in a moment; before we get to it, though, we need to do a little theoretical analysis. Think about the parse tree image, and the SVG language elements that must be present to render it.

This might seem difficult if this article is your first exposure to SVG, but it’s not actually not so hard: the only elements in the image are text elements – renderings of an operator or integer – and lines indicating parent-child relationships. SVG has primitives for both of these; the rest is boilerplate and detail you can ignore for now. So basically, the SVG file will contain a sequence of text definitions and line definitions (just assume all the coordinates are magically calculated for you), arranged in some particular order and subject to some constraint in its organization.

Can you imagine a regular expression that will describe all SVG documents representing expression parse trees? I doubt it, because there is not one. You can verify using the pumping theorem or any similar technique that it is not regular, for the same reason that set of valid expressions is not a regular language either. A context-free grammar representing this class of SVG documents is

svg -> <start> <node> <end>
<node> -> (<opline> <node> <node>) | <TERM>
<TERM> -> ("0".."9")*
<opline> -> <OP> <line_to_leftchild> <line_to_rightchild>
<OP> -> "*" | "+" | "-"

mkparsetree.py will generate such SVG documents, given a preprocessed syntax parse tree (defined in the “data” variable towards the end of the script):

#!/usr/bin/env python
'''
svg -> _start_ _node_ _end_
_node_ -> _node_ _OP_ _node_ | _TERM_
_TERM_ -> 0..9
_OP_ -> * | +

'''

_start = '''<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" version="1.1"
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">
  <desc>Arithmetic Parse Tree</desc>

  <!-- Begin  parse tree data -->
'''

_end = '</svg>'

def _t(x, y, s):
    return '<text font-size="30" x="%s" y="%s">%s</text>\n' % (x, y, s)

def _node(args, x, y, depth):
    op, n1, n2 = args[0], args[1], args[2]
    x_n1 = int(x-100/depth)
    x_n2 = int(x+100/depth)
    y_child = y + 80
    if type(n1) is list:
        n1_s = _node(n1, x_n1, y_child, depth+1)
    else:
        n1_s = _t(x_n1, y_child, n1)
    if type(n2) is list:
        n2_s = _node(n2, x_n2, y_child, depth+1)
    else:
        n2_s = _t(x_n2, y_child, n2)
    s = _t(x, y, op)
    s += n1_s
    s += n2_s
    line_fmt = '<path d="M %d %d L %d %d" stroke="black" ' \
        + 'stroke-width="1"/>\n'
    s += line_fmt % (x+5, y + 15, x_n1+8, y_child - 25)
    s += line_fmt % (x+5, y + 15, x_n2+8, y_child - 25)
    return s

DATA = ['*', ['+', '2', '3'], ['-', '7', ['*', '8', '9']]]

print _start + _node(DATA, 200, 30, 1) + _end

Much of mkhist.py and mkparsetree.py are similar. The interesting difference is in comparing the _bar and _node functions. The _bar function in the histogram generator simply calculates the SVG snippet that will render an appropriate rectangle. The parse tree generator’s_node function, in contrast, may recursively call itself any number of times. In fact, any pair of generators, one for regular-language images and one for context-free-language images, will show some form of this difference.

Does this relate to practical software engineering? You bet. These two models delineate two different broad classes of problems, and provide insight in the kind of algorithms that can effectively address them. Let’s say you need to develop a component that generates images according to some requirements; having read this far, it’s clear that the range of possible images will dictate the nature of the rendering code. Of course, the basic idea is not limited to the domain of two-dimensional graphics; it is more fundamental, and applies to many software engineering problems.

Primeiros passos com o Sphinx 2011/02/01

Posted by gsavix in ciência colaborativa, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Computadores, Conhecimento para receber ou transferir tecnologia, Doc, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, sociologia do conhecimento, Soft.
Tags: , , , , , ,
add a comment

Primeiros passos com Sphinx

Esse documento é para permitir uma visão como um tutorial, nas tarefas mais comuns no uso do Sphinx.

A seta verde designa “mais informações”, através de ligações para seções avançadas descrevendo a tarefa.

Configurando fontes da documentação

O diretório ou pasta raiz, da coleção tem o nome de source directory. Nele também está o arquivo de configuração Sphinx conf.py, onde você pode configurar todos os aspectos, sobre como o Sphinx faz a leitura dos seus fontes e constrói sua documentação. [1]

O Sphinx vem com um script chamado sphinx-quickstart que configura on diretório ou pasta fonte, além de criar um arquivo padrão chamado conf.py com as opções mais comuns, a partir de poucas perguntas feitas para você. Apenas execute:

$ sphinx-quickstart

e responda as perguntas. (Certifique-se de responder yes para a extensão “autodoc”.)

Definindo a estrutura do Documento

Vamos assumir que você já executou sphinx-quickstart. Foi criado um diretório ou pasta contendo o arquivo conf.py e um arquivo com documento mestre index.rst (se você aceitou os padrões). A função principal do master document é servir como página de boas vindas, e conter a raiz da TOC (tabela de Conteúdos) ou (toctree). Isto é uma das principais coisas que o Sphinx adiciona ao reStructuredText, (RST) uma maneira de conectar múltiplos arquivos em uma hierarquia única hierarquia de documentos.

Diretivas reStructuredText

toctree é uma directiva de reStructuredText, uma peça versátil de markup. Diretivas podem conter argumentos, opções e conteúdo.

Argumentos são fornecidos diretamento após (dois pontos) seguidos pelo name da diretiva. Cada diretiva decide quando e quantos argumentos pode ter.

Opções são fornecidas após os argumentos, na forma de “lista de campos”. O maxdepth é uma opção para a diretiva toctree.

Conteúdo seguindo Argumentos ou Opções após uma linha em branco. Cada diretiva decide quando pode haver conteúdo e o que fazer com ele.

Uma pegadinha com diretivas é que a primeira linha do conteúdo precisa estar “indentada” (ou alinhada) à mesma coluna onde a opção está.

A diretiva toctree inicialmente está vazia, e parece com:

.. toctree::
   :maxdepth: 2

Você adiciona documentos na lista, preenchendo o Conteúdo da diretiva:

.. toctree::
   :maxdepth: 2

   intro
   tutorial
   ...

É exatamente assim que toctree para documentação parece. Os documentos para incluir são colocados como nome do documento, os quais de maneira resumida, significa que você não quis informar as extensão do arquivo, e vai utilizar a barra como separador de diretórios ou pastas.

more Leia mais sobre Diretiva toctree.

Você pode criar os arquivos que você inseriu em toctree e adicionar conteúdo, e os títulos deles serão inseridos até o nível especificado por “maxdepth” da diretiva toctree. Agora, o Sphinx sabe a ordem e a hierarquia dos documentos, os quais podem conter diretivas toctree neles mesmos, o que significa que você pode especificar várias hierarquias subordinadas se necessário.

Adicionando conteúdo

Em arquivos fonte Sphinx, você pode usar muitas funcionalidades padrão de (RST) reStructuredText. Além destas, existem outros adicionadas pelo Sphinx. Por exemplo, você pode adicionar referências cruzadas entre arquivos, de uma maneira portável (pois funcionam para todos os tipos de saída), através de ref role.

Por exemplo, se você está vendo a versão HTML, você pode dar uma olhada na fonte do documento – usando o link “Exibir Código Fonte” na barra lateral.

more Veja reStructuredText Princípios para maiores detalhes ao reStructuredText e marcas_sphinx para uma lista completa de marcações adicionadas pelo Sphinx.

Rodando o build

Agora que você adicionou alguns arquivos e conteúdos, vamos fazer nosso primeiro “build” (construir) dos documentos. A construção é iniciada com o programa sphinx-build, o qual é chamado como:

$ sphinx-build -b html diretório_fonte diretório_construído

onde diretório-fonte é onde estão seus arquivos reStructuredText e o diretório_construído é o diretório ou pasta onde você deseja colocar a documentação construída. A opção -b seleciona o construtor; nesse exemplo Sphinx irá construir arquivos HTML.

mais informações Veja chamada para todas as opções que o programa sphinx-build permite.

Contudo, o script sphinx-quickstart cria um arquivo a Makefile e um arquivo make.bat que tornam a vida mais fácil para você, pois para criar a documentação você só precisa escrever:

$ make html

para construir docs HTML no diretório que você escolheu. Execute make sem argumento para ver quais possibilidades estão disponíveis.

Documentando objetos

Um dos principais objetivos do Sphinxs, é a documentação fácil de objetos objetos (em termos gerais) em qualquer domínio. Um domínio é uma coleção de tipos de objetos, que juntos com marcas, criam e referenciam descrições a estes objetos.

O domínio mais importante é o Python. Por ex.: a função interna enumerate(), você pode adicionar isto aos seus arquivos fonte:

.. py:function:: enumerate(sequence[, start=0])

   Retorna um iterator que aponta tuples de um índice e um item de
   *sequência*. (E assim sucessivamente.)

Isso é renderizado (deduzido) como:

enumerate(sequence[, start=0])
Retorna um iterator que aponta tuples de um índice e um item de
sequência. (E assim sucessivamente.)

O argumento da diretiva é a assinatura do objeto que você descreve, o conteúdo é a documentação dele. Múltiplas assinaturas podem ser dadas, cada uma em sua linha.

O domínio Python também ocorre como domínio padrão, portanto você não precisa colocar o prefixo de marcação no nome do domínio:

.. function:: enumerate(sequence[, start=0])

   ...

faz o mesmo se você manter a configuração padrão para domínio.

Existem muitos outras diretivas para documentar outros tipos de objetos Python, por exemplo: py:class or py:method. Existe também uma definição de referência cruzada role para cada um desses objetos. Essa marcação irá criar uma ligação em enumerate():

A função :py:func:`enumerate` pode ser usada para ...

E aqui a prova: Um link para enumerate().

Recapitulando, o prefixo py: pode ser omitido para o domínio Python pois é o padrão. Não importa qual arquivo contem a documentação para enumerate(); O Sphinx irá encontrar e criar um link para este arquivo.

Cada domínio terá regras especiais para como são as assinaturas e fazer a saída formatada aparecer bem formatada ou adicionar funcionalidades como ligação para tipos de parâmetros, ex. em domínios C/C++.

more Veja domínios para todas as diretivas e roles disponíveis.

Configurações básicas

Anteriormente mencionamos que o arquivo conf.py controla como o Sphinx processa seus documentos. Quando este arquivo, é executado como um fonte Python, você assinala cada um dos valores, nele existentes. Para usuários avançados: deste que executado pelo Sphinx, você pode executar tarefas não triviais, a partir deste arquivo, como extensão sys.path our importar um módulo para encontrar a versão que você está documentando. Os valores configurados que você provavelmente deseja modificar, já foram gravados no arquivo conf.py pelo sphinx-quickstart e inicialmente definidos como comentários com a sintaxe padrão Python # torna comentário o resto da linha. Para modificar o valor padrão, remova o # e modifique o conteúdo da variável para o valor desejado. Para personalizar um valor que não foi automaticamente adicionado pelo programa sphinx-quickstart, apenas faça um assinalamente adicional.

Tenha em mente que o arquivo utiliza sintaxe do Python para strings, números, listas e assim por diante. O arquivo é salvo em unicode UTF-8 por padrão como indicado pela declaração de codificação da primeira linha. Se você usar caracteres não ASCII em qualquer valor de string, você precisa utilizar Python Unicode (como project = u'Exposé').

mais informações Veja Arquivo de configuração do build para documentação de todos os valores disponíveis.

Autodoc

Quando documentar código Python, é comum colocar um monte de documentação nos arquivos fonte, em strings de documentação. Sphinx suporta a inclusão de docstrings a partir de seus módulos com uma extensão (uma extensão é um módulo Python que provê funcionalidades adicionais para os projetos Sphinx) chamada “autodoc”.

Para utilizar autodoc, você precisa ativar esta extensão no arquivo conf.py colocando a string 'sphinx.ext.autodoc' na lista assinalada contendo extensions. Então você terá mais diretivas à sua disposição.

Por exemplo, para documentar a função io.open(), lendo sua assinatura e a docstring do arquivo fonte, você escreverá:

.. autofunction:: io.open

Você também pode documentar todas as classes ou mesmo todos os módulos, automáticamente usando as opções de membros para diretivas auto, ficando assim:

.. automodule:: io
   :members:

autodoc precisa importar seus módulos para extrair as docstrings. Todavia, você precisar adicionar o caminho correto para sys.path no seu arquivo conf.py.

mais informações Veja sphinx.ext.autodoc para descrição completa para funcionalidades autodoc.

Mais tópicos serão cobertos

  • Outras extensões (math, intersphinx, viewcode, doctest)
  • Arquivos Státicos
  • Selecionando um tema
  • Modelos (Templating)
  • Usando extensions
  • Escrevendo extensões

Notas de Rodapé

[1] Essa é a formatação usual. Contudo, o arquivo conf.py pode também estar em outro diretório ou pasta, o diretório de configuração. Veja Chamando sphinx-build.

acesso em aplicações web grid computing 2010/03/04

Posted by gsavix in Computadores, Conhecimento.
Tags: , , , ,
add a comment

Novas tecnologias estão disponíveis para acesso sem nenhum custo.

Faço referência especialmente a algumas que o google vem disponibilizando nos últimos 2 anos e que podemos utilizar sem nenhum investimento financeiro. Basta estudá-las e aprender como tirar proveito das mesmas. Nós da Auvix Informática Ltda, já fazemos uso de algumas destas técnicas desde dezembro/2001.

Algumas de nossas utilizações podem ser vistas em:

http://sites.auvix.com.br

http://email.auvix.com.br

http://aplicativos.auvix.com.br

Estas técnicas estão descritas nos emails abaixo! Aproveite!

  1. http://www.google.com/apps/intl/pt-BR/business/index.html
  2. http://www.google.com/apps/intl/pt-BR/business/collaboration.html
  3. http://wordpress.org

Preenchimento de Formulários Google Docs ou App 2010/03/03

Posted by gsavix in Computadores.
Tags: ,
1 comment so far

Algumas informações para a coleta de dados podem vir diretamente da captação de dados distribuidos por emails.

Para editar formulários podemos acessar

Miss Brasil 2000 , será que ela vai continuar ? 2009/09/22

Posted by gsavix in Computadores, Empresas e negócios, Sistemas Computacionais, Sistemas de Gestão da Produção.
Tags: , , , , , , , , , , , , , , , , , , , ,
add a comment

É incrivel mas ainda ontem pude ver ao vivo e a cores, mais uma herança da miss brasil 2000? É sim você deve achar que estou brincando mais não é não! É ela mesmo! Mas como pode ser? Veja se você se recorda…
Há mais de 10 anos estávamos nós mortais da era digital amedrontados e aparvalhados com o tal do bug do milênio. É incrivel mas qualquer zé mané, investido de jornalista saia entrevistando os gênios da bolha .com para saber o que era esse tal de bug do milênio e o que é que iria acontecer pois a Miss Brasil 2000 tinha inventado uma “coisa” muito legal e era simples pois bastava colocar o ano como sufixo e a tal coisa vendia muito, lembra-se “coisa95”, “coisa98” e agora será que a “coisa2000” ou “coisa2k” iria conseguir manter os computadores ligados na passagem do milênio?
Éh!!! parecia coisa de filme e a miss brasil 2000 estava na crista da onda, criando uma grande colcha de retalhos que era vendida a preço de ouro!!!
Nessa época ainda a web não havia explodido como hoje e os hackers ainda trabalhavam com uma rede, eles ainda não sabiam que a miss brasil estava fazendo uma grande emenda que iria transformar-se na gigantesca colcha de retalhos e furos.
Bem passou o milênio e o bug nem aí!
Mas muitas empresas nesta época embarcaram em canoas que dependiam da tal colcha que a miss brasil criou e veja a miss brasil não colocou grandes proteções para que estas empresas que fazem parte da “la garantia sou djô”, não pirateassem essa colcha, pois zé! aqui no Brasil estamos com muitas empresas que ainda hoje estão se debatendo com a tal coisa2000 pois já faz mais de 5 anos que a miss brasil não dá suporte à coisa2000, só que estas empresas estão agora com seus computadores utilizando diariamente ao Deus dará “coisa95” segunda-edição, “coisa98”, “coisa2000” versão desktop e versão server “profissional hein!”. São cópias piratas que estão ajudando as empresas classe “la garantia soy …” a navegar nos turbulentos cenários globais, nacionais e regionais.
O mais interessante é que os ases indomáveis de TI, estão abandonando suas naus em pleno oceano ao Deus dará, pois agora o Brasil está saindo do “marasmo” e o vento está soprando para levar as empresas que estão preparadas para navegar com grande velocidade e com proa segura para dar muitas voltas nos mares verdes do Brasil. Já os proprietários de embarcações que contrataram piratas para conduzir seus negócios agora estão a se perguntar será que a miss brasil 2000 vai continuar sua tradição? nada melhor que a música da Rita Lee Miss Brasil 2000!!!!

ah! eu esqueci de dar mais um detalhe! como os dados utilizavam dbase e clipper 87 a miss brasil liberou uma grande arapuca de banco de dados utilizando SQL que hoje em dia ajuda as empresas a enxergarem os resultados dos negócios através dos buracos da colcha e não conseguem ver dados cristalinos nem terra firme para retirar a colcha que recobriu toda a embarcação.

ps. qualquer semelhança entre a miss brasil e uma grande empresa que produz software é mera coincidência, entre fatos, lugares e empresas.