Alterar componentes do Fragment através de uma Activity

Question: Estou fazendo uma aplicação com NavigationDrawer, e para não criar sempre outra activity, estou usando fragments, onde a cada clique faço o replace no FrameLayout que deixei setado como principal. Como eu acesso os componentes que cada fragment possui? Ex: TextView (alterar o text dele);

Minha classe Fragment
public class EscolheEspecialidadeFragment extends Fragment{

    private TextView tvTeste;
    private View rootView;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        rootView = inflater.inflate(R.layout.fragment_escolhe_especialidade, container, false);
        tvTeste = (TextView)rootView.findViewById(R.id.tvTeste);
        return rootView;
    }

    public void setTextoText(String texto)
    {
        tvTeste.setText(texto);
    }
}

Método responsável por chamar o fragment
public void clickHojeAmanha(View view)
    {
        EscolheEspecialidadeFragment fragment = new EscolheEspecialidadeFragment();

        FragmentManager fn = getFragmentManager();
        fn.beginTransaction().replace(R.id.content_frame, fragment).commit();

        fragment.setTextoText("teste");
    }

Toda vez que a aplicação tenta setar o texto, ela dá crash e encerra. Por favor, onde está o meu erro?
Comment: Você quer que código na *Activity* altere o texto de um *TextView* existente no *layout* do *fragment*?
Comment: Sim, seria possível?
Answer: Cada fragment deve ser responsável por gerir/manipular o conteúdo das suas views.
Se a necessidade dessa alteração surge fora dele, disponibilize métodos públicos que possam ser chamados do exterior.
Por exemplo para alterar o texto de um Textview:
public void setTextViewText(String text){

    textView.setText(text);
}

A activity tem uma referência ao Fragment, quando quiser alterar o texto desse TextView usa o método assim:
fragmentObject.setTextViewText("qualquer coisa");

Comment: Exatamente, deu certo! Obrigado
Comment: o findviewbyid do textview, eu faço na classe do fragment, no onCreateView ou na minha Activity principal?
Comment: Como o *TextView* está no *layout* do *Fragment*, o `findViewById()` tem de ser feito no *Fragment*
Comment: Amigo, por favor. Olhe minha outra resposta com a minha classe
Comment: O problema é que a transacção não é aplicada de imediato após a chamada a *commit*, assim,  quando o método `setTextViewText()` é chamado, o `onCreateView()` ainda não foi executado. Entre a linha onde está o *commit* e a chamada ao método inclua esta: `fn.executePendingTransactions();`


Delete the content of a field from all the node under a specific content type

Question: What would be  the best approach (preferably with GUI) to delete the content of certain fields from certain content types.
I am thinking of using rules but I cant configure to do it.
Ny ideas? Thanks
Comment: Hi ARGO, you seem to have 13 questions with zero accepted answers.  Perhaps you could revisit your previous questions and accept some answers.
Answer: Views Bulk Operations, using the "Modify entity values" action.
Comment: Hi Bojan, How can I use this with rules, upon importing data using feeds?
Answer: You can easily do this with a little piece of code - just use field_attach_update () function.
Here is very good article "Saving node's fields without saving the node itself" that will help you.
Your code can be as follow:
<code>$nids = db_query(
  'SELECT nid FROM {node} WHERE type in (:node_types)',
  array(
    ':node_types' => array('TYPE1', 'TYPE2'),
  )
)->fetchCol();
$nodes = node_load_multiple($nids);

foreach ($nodes as $node) {
  $node->field_fieldname[LANGUAGE_NONE][0]['value'] = 'some value';
  field_attach_presave('node', $node);
  field_attach_update('node', $node);
}
</code>


love 2d Background not appearing

Question: I'm trying to code a game in lua, but the background doesn't appear, only the "witch.png".(https://i.stack.imgur.com/A88Us.png)(https://i.stack.imgur.com/guH66.png)(https://i.stack.imgur.com/SlCA3.png)
I have tried putting most of my code in commentaries, changing my main.lua, nothing seems to be working
Comment: If you knew what you were saying you would have told me that the problem was that my first function wasn't correctly closed. The background size doesn't have anything to do with that because the loop IS to resize automatically the background.
Comment: If you would post the code as a code block instead of random linked images people may actually read your code. Also the first code is correct, not sure what error you found
Comment: If the resolution of your background is larger than the screen, the loop will never loop thus not render.
Comment: The background and the width/height of the screen both are 1920x1080.
Comment: I have to correct myself, since your loop starts at `0` it indeed works. It works too well however, if your background is exactly the screen size you waste 3 draw calls.
Answer: I think the problem has been solved in the comments, but there is currently no answer posted. There are two function love.draw(), and the second one does not have the loop for the background. This can be easily solved by moving the loop to the second function and deleting the first function.

love 2d Background not appearing


Integral problem, how do I solve?

Question: $$\int_0^a  e^{1-2x}\, dx = \frac e4$$
My problem is solving for $a$
Comment: http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
Comment: Use MathJaX to write here, or very few people will even attempt to understand what you wrote.
Comment: Are you able to compute the integral?  Hint:  $e^{1-2x}=e\times e^{-2x}$.
Comment: sorry I have been having trouble writing in mathjax,
Comment: Yes I am able to compute the integral, my issue is solving with e
Comment: Can you edit your post to show your computation of the integral?
Comment: @SaraBlank That $\;e\;$ multiplying there is *only a constant*: take it out of the integral!
Comment: $/e\int{0_a} e^(-2x)
Comment: Yes, you can bring the constant out.  Can you actually compute the integral?
Comment: Yes I could and i got 1/2(e-e^(1-2a))
Answer: Hints:
$$\begin{align*}&e^{1-2x}=e\cdot e^{-2x}\\{}\\
&\int e^{kx}dx=\frac1ke^x+C\end{align*}$$
Answer:
Substitute $u=-2x$ and $\text{d}u=-2\space\text{d}x$
$$\int e^{1-2x}\space\text{d}x=\int e\cdot e^{-2x}\space\text{d}x=e\int e^{-2x}\space\text{d}x=-\frac{e}{2}\int e^u\space\text{d}u=\text{C}-\frac{e^{1-2x}}{2}$$
$$\int_0^ae^{1-2x}\space\text{d}x=\left[-\frac{e^{1-2x}}{2}\right]_0^a=-\frac{1}{2}\cdot\left[e^{1-2x}\right]_0^a=-\frac{e^{1-2a}-e^{1-2\cdot0}}{2}=\frac{e-e^{1-2a}}{2}$$
$$\int_0^ae^{1-2x}\space\text{d}x=\frac{e}{4}\Longleftrightarrow\frac{e-e^{1-2a}}{2}=\frac{e}{4}\Longleftrightarrow a=\frac{\ln(2)}{2}$$
Answer: Another way to solve it using a change of variable (Even though it is easier to factor out one $e$ of course...):
$$
t = 1 -2x \\
dt = -2 dx \implies dx = \frac{-dt}{2} \\
x = 0 \implies t = 1-2\cdot 0 = 1\\
x = a \implies t = 1-2a
$$
Then
$$
\int_0^a e^{1-2x} = \int_1^{1-2a} e^t \cdot \frac{-dt}{2} = -\frac{1}{2} [e^t]^{1-2a}_1 = -\frac{1}{2} (e^{1-2a}-e)
$$
So you want
$$
 -\frac{1}{2} (e^{1-2a}-e) = e/4 \implies -\frac{1}{2}(e^{-2a} -1) = 1/4 \implies e^{-2a} = \frac{1}{2}
$$
Taking log :
$$
-2a = -\ln(2) \implies a = \ln(2)/2
$$
Comment: I understood everything...except from how you get from -1/2(e^1-2a -e) =e/4, to it equalling 1/4
Comment: $(e^{1-2a}-e) = e(e^{-2a}-1)$
So you then divide by $e$ on each side.

Integral problem, how do I solve?


Where does the summation convention break?

Question: In my work I have spotted something "weird". Consider the matrix
\begin{align*}
  M_{ij} =1-\delta_{ij}.
\end{align*}
I want to find $ M^{2} $  in terms of its components. So
\begin{align*}
  (M^{2})_{ij}
   =(M M)_{ij}& =M_{ia}M_{aj} \tag{1}\\
  & = (1-\delta_{ia})(1-\delta_{aj}) \tag{2}\\
  & =1+\delta_{ia}\delta_{aj}-\delta_{ia}-\delta_{aj} \tag{3}\\
  & =1+\delta_{ij}-1 -1 \tag{4}\\
  & =-1+\delta_{ij},\tag{5}
\end{align*}
however, this is clearly wrong, as consider $ n=2 $ , in which case we have
\begin{align*}
  \begin{pmatrix} 0 &  1 \\
                  1 &0
  \end{pmatrix}
  \begin{pmatrix} 0 &  1 \\
                  1 &  0
  \end{pmatrix}
  =\begin{pmatrix} 1 &  0 \\
                  0 &  1
  \end{pmatrix}
  .
\end{align*}
A guess where this goes wrong is from $ (1) $ to $ (2) $ as expanding $ (3) $ gives $ k $  as a free index, over which I have summed over. I did so because I couldn't leave it since it is a dummy variable. My best guess is that I am simply not allowed to go from $ (1) $  to $ (2) $  but I am not sure as to why that is.
If anybody could shine some light on this I would greatly appriciate it.
Comment: Is your matrix the matrix of ones except on the diagonal where it is zero?
Comment: @CameronWilliams yes.
Answer: The $1$ in the definition is a matrix, not a number, and should be written as $1_{ij}$. ($J_{ij}$ would be better because the matrix of all ones doesn't act like the multiplicative identity, but I will leave it as $1_{ij}$.) Not writing the indices here causes problems later.
Following your derivation, we get
\begin{align*}
  M_{ij} =1_{ij}-\delta_{ij},
\end{align*}
and computing $M^2$, we get
\begin{align*}
  (M^{2})_{ij}
   =(M M)_{ij}& =M_{ia}M_{aj} \tag{1}\\
  & = (1_{ia}-\delta_{ia})(1_{aj}-\delta_{aj}) \tag{2}\\
  & =1_{ia}1_{aj}+\delta_{ia}\delta_{aj}-\delta_{ia}1_{aj}-1_{ia}\delta_{aj} \tag{3}\\
  & =n 1_{ij}+\delta_{ij}-1_{ij} -1_{ij} \tag{4}\\
  & =(n-2) 1_{ij} +\delta_{ij},\tag{5}
\end{align*}
where we see the important error occurred in equation 4, where $1_{ia}1_{aj} = n 1_{ij} \neq 1_{ij}$
Comment: I don't think I can answer that question verbally or fully - it might be better to ask that in a separate question. For a too-tight response, the summation convention is fine if (1) you only have sums and products, (2) each term doesn't use an index more than twice, (3) you don't add terms with different free indices, and (4) both sides of the equation have the same free indices. I believe you can extend (1) to allow linear transformations, but I am not sure of a more general answer.
Comment: Thank you very much for the answer. A quick question on the summation convention: generally, can we always multiply terms, in other words, given two expressions each with say two free indecies $a$ and $b$, can we always multiply them out and apply the summation convention?
Comment: I don't understand your question fully. However, if each term has the proper number of indices (so you are never adding/subtracting terms with different indices), then the summation convention should work, as it would just be ignoring the same $\sum$s at the front of the expression.
Comment: Hi thank you for the response. I wanted to ask you, are there any circumstances in which the summation convention breaks - that is- places where I should be avoiding using it?
Comment: Thank you for the help and the phenomenal answer.
Answer: (1) is already wrong—the right-hand side should be $\displaystyle\sum_{a=1}^n M_{ia}M_{aj}$, with a summation sign. This will eventually expand to
$$
\sum_{a=1}^n 1 - \sum_{a=1}^n \delta_{ia} - \sum_{a=1}^n \delta_{aj} + \sum_{a=1}^n \delta_{ia}\delta_{aj},
$$
from which you should be able to recover the correct answer. (In your method, you guessed to sum certain parts of the formula but not all of them; writing the sums explicitly takes the guesswork away.)
Comment: The summation sign can be nice to have as a learning tool, but it is often elided by convention. So insisting that should be there isn't quite right in my opinion.
Comment: @Arthur But omitting it when some of the symbols have no indices is bound to lead to misunderstandings.
Comment: @TedShifrin This is very true. If you want implicit summation, then each term needs to have free indices that match those of every other term in order to be clear.
Answer: Let $A=(1-\delta_{ij})$, a matrix of order $n$. Then an easy calculation show that $A$ looks like a matrix which have all the entries with $1$ except when $i=j$ and it least case the matrix have only $0$ in the diagonal.
If you calculate $A^2$ you can notice that we always sum the $1$ by each entry except when we multiply the entry with $i=j$. Hence we always have in all the entries with $i=j$the sum of $n-1$ ones. Otherwise we always sum $1$ in all the entries except when $i=j$ twice (in the row and in the column of $A$), which give the sum of $n-2$ ones. As result, if $A$ is a matrix of order $n$ and $A$ is written as above.
$$A^2=(a_{ij})=\begin{cases}a_{ij}=n-1 \, \text{if i=j } \\ a_{ij}=n-2 \, \text{if $i\neq j$} \end{cases}.$$
Comment: Hi @Brien, thank you for the anwer. I know the answer, I want to understand why is what I have written wrong. Any ideas?
Comment: It seems because if $A=(a_{ij})$ the matrix $A^2\neq (a_{ij})(a_{ij})$
Comment: You can find the general formula for the product of two matrix $A$ and $B$ here and apply the product rule correctly  where $A=A$ and $B=A$. https://en.wikipedia.org/wiki/Matrix_multiplication


Muitas telas ou uma tela com muitas informações?

Question: Eu vejo uma tendência cada vez maior, embora isto já existisse antes, de criar várias telas, vários passos para executar uma única ação.
Claro que o advento de telas menores incentiva isto. Mas estou falando de desktop normal. O mesmo vale para aplicações web "normais" (que não são feitas para rodar em mobile).
Também entendo que telas superpopuladas de informação, que permitem fazer várias coisas, muitas vezes não relacionadas, não fazem sentido. Mas percebo que antes o que você fazia em um click, em interfaces modernizadas acabam exigindo dois, três ou mais clicks para se alcançar o mesmo propósito. Muitas vezes você limpa a tela mas dificulta o acesso à operação desejada.
Este tipo de filosofia, me parece, prejudica a descoberta da operação.
Realmente atrapalha ter muita informação? Por que?
Existem estudos ou pelo menos informações consistentes que mostram que um realmente é melhor que outro? Por que esconder operações é melhor? E se não é, por que estão adotando isto? Seria interessante ver um comparação entre as duas situações para entender as vantagens e desvantagens de cada uma, e com isto ajudar a entender quando e optar por um mais que o outro.
Existe alguma forma de facilitar a descoberta, facilitar o acesso às operações, sem "sujar" a tela? Há exceções onde não devemos aplicar uma destas filosofias?
Comment: Teria um exemplo, de cada uma das duas situação? Para podermos compreender melhor as "filosofias" que você está citando. E suas reais diferenças, dificuldades e operações "escondidas".
Comment: Estou tentando achar um antes ou depois para postar, se achar algo legal, eu edito. que mostre bem isto. Mas falo em termos gerais. Só para não deixar sem nenhum exemplo: para chegar em http://pt.stackoverflow.com/help/mcve precisa de 4 cliques. Antes precisa de menos. Outro exemplo é o uso de abas ao invés de divisões na tela. Eu vejo aplicações que chegam ao ponto de exigir ficar trocando de tela para comparar as informações. Apesar de entender que isto tem a ver com o mobile, o Windows 8 elevou isto: http://ux.stackexchange.com/questions/31207/ O Gmail é um bom exemplo como mudou.
Answer: TL;DR
Realmente atrapalha ter muita informação? Por que?
Em teoria sim. Porque a capacidade da atenção humana é limitada. O usuário pode não perceber o que deveria, e mesmo que o faça isso pode gerar esforço cognitivo demasiado para uma interação mais continuada.
Existem estudos ou pelo menos informações consistentes que mostram que um realmente é melhor que outro?
Existem inúmeros. Mas os estudos mais gerais servem como abordagem padrão. O melhor estudo para você vai ser aquele que você fizer com os seus usuários usando protótipos do produto que prepara para eles.
Por que esconder operações é melhor? E se não é por que estão adotando isto?
Pode ser melhor esconder porque facilita a interação local do usuário (ele não precisa se preocupar com o que não é importante no contexto atual). Porém, o usuário jamais deveria precisar se lembrar de muita informação. Novamente, a capacidade humana é limitada.
Existe alguma forma de facilitar a descoberta, facilitar o acesso às operações sem "sujar" a tela?
Existem inúmeras, todas usando algum dos sentidos humanos (afinal, o usuário precisa ser capaz de perceber a informação passada). Jogos, por exemplo, fazem uso metódico - e condizente com a fantasia (leia-se, conhecimento prévio do usuário) - de sons. O exemplo clássico é o som de espadas se chocando no Age of Empires, que indica que uma batalha se inicia fora da tela do usuário. Aplicativos móveis também vibram o dispositivo. Enfim, você não precisa necessariamente usar a tela para passar alguma informação.
Há exceções onde não devemos aplicar uma destas filosofias?
Certamente há. A mais óbvia é a construção de aplicativos para cegos. Nesse caso não importa a quantidade, a tela não é a melhor forma de transmitir as informações. Pode parecer um exemplo extremo, mas a ideia é que essas exceções decorrem da sua própria análise dos seus usuários, com as preferências, expectativas e necessidades deles.
Versão original e mais completa
Há duas coisas que são muito importantes de serem consideradas no projeto de interação com um produto: apelo e engajamento.
O apelo está diretamente relacionado às preferências do utilizador e às questões estéticas do produto, como o quão agradável, belo e curioso ele parece. Trata-se de um primeiro nível da interação, em que o utilizador escolhe começar a utilizar o produto. Já o engajamento, embora também inclua atributos de preferência e estética, tem uma relação mais forte com a satisfação na experiência de uso. Trata-se de um contato mais contínuo, em que o usuário escolhe continuar interagindo com o produto. Se as expectativas criadas no primeiro contato com o produto são satisfeitas ou superadas de forma positiva na continuidade do contato, geralmente têm-se o engajamento.
Apelo, Quantidade de Informação e Esforço Cognitivo
O apelo está intimamente ligado à curiosidade, que é uma necessidade humana básica de entender o mundo. Essa necessidade advém de e conduz a interação. Nós humanos interagimos com o mundo não apenas alterando-o por meio de nossas ações, mas também percebendo as mudanças que nós mesmos e outros agentes fazem nele. Acontece que o mecanismo de atenção (que filtra a enorme quantidade de dados sensoriais que continuamente recebemos do mundo e decide o que é relavante ou não de acordo com as nossas intenções) é limitado. Estima-se* que cada pessoa pode processar 126 bits de informação por segundo, o que significa que somos capazes de prestar atenção a um máximo teórico de três conversas simultâneas (isso se conseguirmos ignorar completamente todo o resto, como as percepções internas do nosso próprio organismo).
* A fonte dessa informação é o trabalho do psicólogo Mihaly Csikszentmihalyi, no livro Flow: The Psychology of Optimal Experience. Quem desejar ler sobre o assunto de interação, atenção e motivação, de forma (talvez) um pouco mais facilitada, pode ler este meu artigo sobre diversão.

Se você não acredita nesta limitação da atenção, faça o teste e tente contar o
  número de passes do time branco neste famoso vídeo. :)

É por isso que a evolução fez o cérebro se interessar tanto em padrões levemente desconhecidos. Ao observar algo que não tem novidade alguma, esse algo é simplesmente desinteressante (já conhecemos o assunto, não nos interessa pois não vai ajudar o organismo a se sair melhor nas ações com o mundo). Porém, por outro lado, se esse algo é completamente desconhecido e incapaz de ser ao menos comparado a outra coisa que se conhece, ele é caótico e consequentemente também desinteressante. Por isso que uma tela de TV só com estática, que tem muitíssima informação do ponto de vista da Teoria da Informação, é simplesmente chata e não causa sequer um início de apelo. Mas é por isso também que puzzles muito difíceis, por mais apelativos que sejam inicialmente, dificultam o engajamento porque os usuários simplesmente não conseguem saber como prosseguir.
Todo esse bla-bla-bla teórico é pra demonstrar que há um ponto ideal na quantidade de informações a ser exibida. Ela deve ser suficiente para causar apelo e excitar a curiosidade (e não pense só em jogos; um alarme em um sistema de controle de fábrica precisa ser capaz de atrair a atenção rapidamente!), mas não pode exceder as limitações naturais dos seres humanos a ponto de causar desconforto e assim dificultar o engajamento. Mesmo que muita informação seja compreendida e cause apelo, ela pode requerer muito esforço cognitivo e assim simplesmente cansar o usuário. É por isso que lá nos Princípios de Usabilidade prega-se, entre outras coisas, evitar que o usuário tenha de se lembrar do caminho nos menus para um comando, por exemplo.
Note, entretanto, que a mera existência de muita informação nem sempre é ruim. Ruim é alagar o usuário com toda ela de uma vez só, tornando-o incapaz de extrair algo de útil dela. O resultado de uma pesquisa no Google, por exemplo, tem muitísima informação, mas ela está espalhada ao longo de páginas facilmente navegáveis. E, principalmente, é muito claro ao usuário que existe essa possibilidade (ele percebe que há mais dados além dos que está enxergando atualmente). De fato, aqui há a ligação com o esforço físico do próximo tópico: o usuário pode não se importar tanto em ter de navegar para o próximo item muitas vezes, contanto que essa ação de navegar seja relevante e simples.
O exemplo que você usou na pergunta (a interface cheia de campos) é intrinsicamente pior porque o usuário não sabe o que fazer a seguir do que pelo fato de ele ter disponível toda aquela quantidade de informação. Este fantástico artigo, chamado Desmystifying UX Design, tem muito mais informações relevantes a esse respeito.
Engajamento e Esforço Ergonômico
O esforço ergonômico, ou de uso (como o número de cliques), é mais relevante no engajamento do que no apelo. Isso é natural, pois durante o primeiro contato o usuário ainda não usou o produto propriamente e só tem expectativas a respeito de como será interagir com ele. O esforço cognitivo, tratado no tópico anterior, já é iniciado a partir do primeiro contato, quando o usuário procura entender como funciona o produto.
É uma tendência acreditar que muito esforço físico prejudica o engajamento porque faz o usuário simplesmente cansar de interagir com o produto. Por exemplo, o jogo de luta de boxe do Nintendo Wii pode parecer muitíssimo interessante em um primeiro contato (tem grande apelo), mas após algumas partidas o cansaço físico de ter de socar o ar continuamente pode tornar a experiência menos satisfatória do que se imaginava. Ainda assim isso não é uma verdade universal, pois tudo depende das preferências e das expectativas que são criadas nos usuários durante o apelo. Há usuários que têm imensa satisfação em dispender esforço físico, e certamente irão perceber que esse é o tipo de jogo pra eles a partir das primeiras interações.
Em outras palavras, não é o esforço em si que prejudica o engajamento, e sim a percepção de sua relevância por parte dos usuários. No artigo que eu citei anteriormente sobre a desmistificação da UX, há o exemplo do maior número de cliques em uma interface de Assistente (Wizard), mas que é percebido como facilitador pelos usuários porque não requerem grande esforço físico ou cognitivo individualmente, não sobrecarregam o usuário com perguntas, e permitem que ele atinja o objetivo de forma gradual.
Eu infelizmente não tenho mais a referência desse estudo, mas o mecanismo de subir o vidro elétrico dos carros com apenas um toque veio de testes de empresas automotoras japonesas com seus usuários, em que se observou justamente esse fato. Nas primeiras versões, os usuários eram requeridos a continuar apertando o botão para que o vidro subisse ou descesse. Por mais rápido que o vidro subisse, os usuários sempre reclamavam que o mecanismo era lento demais (mesmo que fosse muito mais rápido do que girar uma manivela, como era feito até então). Acontece que continuar pressionando o botão significa realizar esforço físico, mesmo que bem menor do que girar a manivela. Mas a percepção do resultado por aquele esforço era muito pequena, comparativamente. Enquanto se estava segurando o botão - uma tarefa tão simples a ponto de ser ridícula - o tempo parecia passar mais devagar porque a sensação de ociosidade (idleness) era enorme. Por isso os japoneses criaram o subir/descer automático a partir de um toque. :)
Aliás, há estudos que também observaram esse fenômeno da relação da ação com o tempo. Após intencionalmente distorcer a percepção de tempo ("enganando" os participantes com relógios que passam mais rapidamente), comprovou-se que mesmo tarefas consideradas muito chatas (como contar palitos de fósforo!) são experienciadas como mais prazeirosas por causa dessa percepção de tempo voando...
E como Planejar a Interação
A melhor forma, segundo todas as fontes de UX que eu já estudei e a minha própria experiência, é a avaliação da interação diretamente com os usuários, principalmente usando protótipos de baixa fidelidade (como construídos em papel). A baixa fidelidade do protótipo facilita a construção (em termos de custo e tempo) e evita que o projetista tenha apego ao produto criado (essa interface ficou tão bonitinha e o usuário não gostou... ah, ele é que não sabe o que quer... my precious!). Além disso, a avaliação permite observar os pontos críticos em todos os aspectos discutidos anteriormente. Sobre esse assunto, eu sugiro também ler esta outra pergunta sobre o que são Wireframes, Mockups e Protótipos e o livro Interaction Design: Beyond Human-Computer Interaction.
Comment: Quem imaginaria que logo você iria dar uma resposta deste nível sobre este assunto? :D
Comment: +1 Se alguém vir um TL;DR no inicio dessa resposta e pular o resto... **volte lá e continue lendo até o final pois vale a pena!**
Answer: Bom, no seu caso a pergunta pode mudar com o decorrer do tempo. Pois a de 3 à 5 anos atrás as interfaces de hoje não seriam possíveis.
Não existe uma convenção da "melhor forma de trabalhar" com design de interfaces, até por que, cada projeto possui requisitos diferentes.
Ao desenvolver uma interface deve ser levado em conta alguns critérios, como:
Clareza
Clareza, segundo Kevin Matz, é um dos principais objetivos ao desenvolver uma interface. Pois o intuito é elaborar uma interface onde o usuário consiga interagir e entender como ela funciona.
Claro que a "quantidade de clicks" deve ser levado em conta, porém não deve-se superar a clareza e a utilidade de sua interface.
Atenção
Vivemos com vários fatores que tiram nossa atenção, ao decorrer do dia. Sua interface deve ser capaz de lidar com fatores externos.
Não coloque em sua "tela", informações que podem tirar a atenção do usuário. Sua aplicação deverá ser capaz de lidar com esse fator.
Objetivo
Adicionar em uma tela várias funcionalidades por deixar "mais fácil", acaba prejudicando
a interação do usuário com a sua aplicação. Pois em meio a muitas funcionalidades, ele acaba se "perdendo", dificultando o acesso.
Cada tela deve ser focada em um objetivo final, deixando assim o método de aprendizado e memorização por parte do usuário mais fácil. Afinal, quando desenvolvemos uma aplicação, seja ela Desktop, Web ou Mobile, ela será utilizada por N tipos de usuários, cada um com sua forma de aprendizado.
Outras Operações
Quando for necessário adicionar "Operações Secundárias" em sua tela, certifique que o usuário saiba que esta é uma Operação Secundária, que ela está ali apenas como complemento, e não para ser a atenção principal.
Exemplo: Uma opção para compartilhar uma foto no facebook, está ali apenas como complemento. O objetivo principal é que as pessoas possam ver e interagir com a foto, compartilhar a mesma se torna uma fator secundário.
Respondendo a sua pergunta diretamente, tendo em vista que deixar um número maior de telas, deixará sua aplicação "mais fácil" de se interagir, não há problemas, pelo contrário. O intuito de uma "Interface Amigável" é elaborar uma forma de interação, onde o usuário não sinta dificuldades ao interagir com sua aplicação.

Resumindo: Não leve em conta a "quantidade de telas ou botões", e sim "a forma de interação com o usuário", pois isso que irá definir se sua interface está clara ou não.
Deixarei algumas fontes, ligadas diretamente e indiretamente com sua dúvida:
Gestalt - Indiretamente ligado a sua dúvida.
Gestalt Interface Design
User Interface
UI Design

The Future of UI
Avaliação de Interfaces de Usuário – Conceitos e
Métodos
Answer: Primeiro uma introdução
Relação Aplicação x Usuário
Existe entre aplicação e usuário uma relação que
quando duradoura modela a ambos.
Primeiro contato
Quando a relação se estabelece, ou seja, quando o
usuário tem o primeiro contato com a aplicação,
o que acontece é que o usuário vai gostar ou não
daquilo baseado em seus gostos pessoais... que na
minha opinião está intimamente relacionado às
experiências passadas.
Se o usuário está acostumado com interfaces limpas,
ou interfaces mais populadas, ou interfaces de linha
de comando, ou GUI's ele vai imediatamente ter uma
impressão baseada nas experiências passadas.
Mas o que isso tem há ver?
Para mim, não existem interfaces boas ou ruins.
O que existe para mim são:

interfaces que seguem padrões estabelecidos,
ou tentam criar o seu próprio padrão.

O primeiro caso, vai com certeza causar um
impacto muito menor nos usuários, e vai se adequar
às experiencias de uma gama maior de usuários.
O segundo caso, vai ter mais dificuldade em
conquistar usuários, exatamente pelo fato, de as
coisas não estarem onde elas esperam que estejam.
Moldagem bidirecional com o tempo
Com o passar do tempo, a aplicação, tanto como os
utilizadores vão mudando e um vai moldando o outro.
Se a aplicação muda, e desagrada alguém, é possível
que esse usuário migre para um concorrente.
Se muitos usuários pedem dada alteração, então
uma fabricante de software provavelmente às ouvirá,
assim moldando o software.
Assim sendo as interfaces mudam, seguindo
indicadores de tendências, baseadas nos usuários,
e seus objetivos.
Agora tenta mudar algo que está culturalmente
entranhado, igual ao botão Iniciar no Windows.
Ou então deixar a interface totalmente sem nada
igual o que queriam fazer com o Microsoft Office.
Ou seja, existe uma questão da experiência passada
até entre versões do mesmo software.
Relação Aplicação x Objetivo
Uma organização específica de uma aplicação qualquer,
além de estar relacionada com as experiências do
usuário, também está relacionada ao objetivo dela
(quanta novidade!).
Só que isso possui implicações, sobre os questionamentos,
afinal uma interface mais populada dá agilidade para o
usuário treinado, enquanto uma interface mais limpinha
dá uma interface menos assustadora para os usuários
ocasionais, fuçadores e a massa em geral.
Respostas:
Realmente atrapalha ter muita informação? Por que?
Me embasando no que disse anteriormente, para mim,
a resposta é nenhum tipo de organização atrapalha,
caso o usuário já esteja acostumado, e também o uso
da aplicação corresponda ao objetivo
Existem estudos ou pelo menos informações consistentes que mostram que um realmente é melhor que outro?
Certamente... mas eu vou dar uma de Sócrates, e
tentar responder usando somente o plano das idéias,
com argumentos meus.
Se for realmente muito importante posso procurar alguns.
Geralmente são estudos relacionados aos termos UX.
Já vi estudos até sobre a posição que os labels devem
ficar em relação às caixas onde se entra com os dados...
só não me lembro onde.
Por que esconder operações é melhor?
Não acho que seja melhor... para mim, é uma estratégia de
marketing, você atinge as massas pois não assusta o fuçador,
o explorador. E também não limita o cara que
vai se aprofundar na aplicação, a pesar de este cara
ser prejudicado na agilidade.
E se não é por que estão adotando isto?
Pois o mercado para utilizadores que requerem agilidade
é menor. Não quer dizer que não exista. Imagine um software
para monitorar um reator nuclear... tem que estar tudo
a um dedo de distância... a um olhar de distância.
Existe alguma forma de facilitar a descoberta, facilitar o acesso às operações sem "sujar" a tela?
Acho que sim.
No futuro talvez só de pensar em algo, já aconteça...
mas atendo ao presente, acho que o legal seria juntar o
melhor dos dois mundos:

a aplicação vem de fábrica muito limpa
ela seria customizável para que o usuário monte o seu próprio painel de controle, mega-powerful
se a organização (empresa) desejar, deve haver uma forma de forçar um layout,
para então treinar os funcionários naquele layout
poderia haver uma forma de compartilhar um layout customizado, globalmente,
criando assim um padrão global para utilizadores de uma certa aplicação,
endossados ou não pelo criador da aplicação

Há exceções onde não devemos aplicar uma destas filosofias?
Com certeza.
Depende do requisito de grau de agilidade necessário para os utilizadores.
Depende do requisito estético do cliente específico.
Há tantos requisitos que podem limitar a interface.
Epílogo
Isso aqui é a minha opinião... como desenvolvedor, utilizador,
pensador... Minhas experiências passadas certamente influenciaram
este texto. Então com certeza, isso tudo é menos que uma fração
pequena das possibilidades.
Comment: Muito boa resposta. Realmente, faltou alguma indicação de fontes, mas a sua abordagem socrática tá no caminho certo. :)
Answer: Ter muita informação a priori não atrapalha nem ajuda.
Depende de quem é o foco da sua aplicação.
Se você utilizar o Princípio de Pareto/Princípio 80-20 (que está na base do conceito da Cauda Longa), pode entender que 80% dos visitantes vão utilizar 20% das funcionalidades/informações e 20% dos visitantes vão utilizar 80% das funcionalidades/informações. Ou seja, disponibilizar mais funcionalidades/informações vai garantir uma forma mais refinada para um público menor, porém especializado, mas é possível que afaste aqueles menos especializados, menos íntimos do conteúdo. Ao passo que menos informações vai garantir um maior entendimento por um público maior mas pode frustar os mais especializados.
Acho que a discussão tem relação com o texto Getting Real, da ex-37Signal, atual Basecamp. http://gettingreal.37signals.com/GR_por.php#ch01
Eles são muito radicais neste ponto.
Resumidamente, eles colocam da seguinte forma:

Getting Real é o menor, mais rápido e melhor caminho para construir
software.
Getting Real é menos. Menos massa, menos software, menos
funcionalidades, menos papéis, menos tudo que não é essencial (e a
maioria do que você pensa ser essencial realmente não é).
Getting Real é permanecer pequeno e ser ágil.
Getting Real é sobre iterações e baixar os custos da mudança.
Getting Real tem tudo a ver com lançamento, refinamento e melhorar
constantemente, o que o torna o caminho perfeito para software
baseado em web.

Com a febre dos One-page Sites, é muito comum ver criadores na tentativa de encaixar seu conteúdo neste modelo sem, ao menos, avaliar se esta solução é a melhor para seu objetivo.
De fato pode ser mais simples colocar todas as informações em uma única página para contar uma história, por exemplo. Rolar a tela é muito mais prático e intuitivo que clicar em 4 ou 5 botões e visitar todo o conteúdo. Mas dependendo do tamanho do conteúdo e dos desdobramentos, o ideal é ter multiplas telas.
No cadastro em uma loja online, por exemplo. Talvez o mais simples seja dividir a finalização da compra em multiplas telas ao invés de disponibilizar uma única e grande página com tudo.
Não há uma resposta única para a pergunta, o ideal é pensar simples, monitorar e aumentar a complexidade da aplicação sob demanda adquirida no monitoramento — usar a estatística que diferencia este meio de outros não digitais. Quando digo mais simples, é pensando neste usuário padrão, por vezes for dummies mesmo, e isso não significa que o projeto não seja bom, certo?
Comment: @LuizVieira Tem razão sobre o foco da resposta, mas o mesmo raciocínio não se aplica ao que está na pergunta? Avaliar objetivamente o uso (seja em protótipo ou em "beta eterno") é uma boa maneira de decidir o que ocultar, ou remover, dependendo do caso. Deixando de lado os modismos de sair escondendo tudo, tem muito "depende" envolvido. Quando na sua resposta você fala em "ponto ideal", entendo que ele varie em função do que a aplicação faz, e do público-alvo, certo?
Comment: Eu acho que você focou a sua resposta no caráter funcional da aplicação (oferecer menos ou mais funções). Porém, a questão é mais no sentido do acesso às funções (sejam elas em quaisquer quantidades), por meio da UI. A referência que você passou é interessante, mas principalmente nesse item que você não citou: "*Caindo na Real inicia com a construção da interface, ou seja, as telas reais que as pessoas irão utilizar. Começa com as experiências reais dos clientes, construindo a partir disso para trás.*" Ou seja, começa a partir da prototipação da UI para avaliar a interação dos usuários. :)
Comment: @bfavaretto Não estou seguro de que se aplique exatamente o mesmo raciocínio. Veja, por exemplo, essa passagem da resposta: "Ou seja, disponibilizar mais funcionalidades/informações vai garantir uma forma mais refinada para um público menor, porém especializado [...]". O que é um público especializado? E isso não é necessariamente verdade. Talvez o AR esteja imaginando um usuário especialista em Bash no Unix, por exemplo, que já conhece muitos dos comandos existentes. Mas o fato é que a interface que ele usa é simples, e **não tem** todos os comandos disponíveis ali, exibidos todo o tempo.
Comment: @bfavaretto Além do mais, muito embora um protótipo possa ser utilizado para entender a necessidade do cliente, não faz sentido esconder alguma função que o usuário nunca irá utilizar. Se é algo desnecessário, nem deveria ser implementado (quanto mais exibido/escondido). Por isso me parece que o foco da pergunta é mais no sentido da experiência e da usabilidade com as funções necessárias/existentes. De todas as formas, eu acho que essa resposta é bacana no sentido de que auxilia também com esse tipo de discussão que estamos tendo. :)
Answer: Desculpem o meu pragmatismo mas, depois de ler as resposta existente até ao momento e de ler alguns artigos sobre o assunto, a minha resposta só pode ser:
Ponham-se na "pele do utilizador" quando forem desenvolver/idealizar qualquer UI.
Nota: Não me penalizem por postar isto como resposta e não como comentário.
Comment: É isso ai. :) Dica de onde continuar a fundamentação da sua resposta: [User-Centered Design](http://en.wikipedia.org/wiki/User-centered_design). "*The chief difference from other product design philosophies is that user-centered design tries to optimize the product around how users can, want, or need to use the product, rather than forcing the users to change their behavior to accommodate the product.*"
Comment: A resposta faz sentido, não achei ela ruim não, mas acho que salvaria ela se coloque um pouco mais o que isto significa. Por exemplo, minha pergunta ocorreu porque eu não gosto de ficar dando vários clicks p/ chegar onde eu quero. Não tenho certeza se isto é o que outras pessoas pensam.
Comment: *"não gosto de ficar dando vários clicks p/ chegar onde eu quero."* refere-se a situações em particular ou é sempre assim?. Nessa altura você pensou: *"Eu faria isto diferente?"*. É uma questão de opinião. Este é um assunto amplamente estudado mas os resultados tem de ser vistos apenas como princípios a ter em conta e não como verdades absolutas. Na minha opinião aqui deve imperar o bom senso, um equilíbrio entre quantidade de informação/relação entre ela e usabilidade. Pôr-me na "pele do utilizador" é a regra que eu sigo primeiro, o *feedback* recebido é o que irá *"afinar"* a solução.
Comment: @LuizVieira, Vou ler.
Answer: Acho que varia muito de aplicação para aplicação. Ao meu ver, temos que aplicativos com muita informação podem ser úteis para quem precisa de mais agilidade no processo e busca descobrir tudo que precisa em menor tempo. Porém, uma tela "pesada" para alguns usuários pode fazer com que a sua aplicação seja uma experiência cansativa e que não atenda muito ao objetivo dos mesmos (já que muitas pessoas têm preguiça de procurar as coisas).
A escolha entre uma tela com muita informação ou com pouca informação e mais telas, deve ser cuidadosamente analisada de acordo com o objetivo do software e o público alvo.
Comment: Você poderia fundamentar isto? Ou é apenas a sua opinião? Note que existem perguntas específicas que escrevi. Elas não precisam ser respondidas diretamente mas precisa ter informações que ajudem informar alguma coisa, pelo menos ajudar tomar uma decisão. A sua resposta diz para fazer justamente o que eu estou perguntando. Como analisar cuidadosamente? Quais critérios usar?
Comment: Foi apenas minha opinião mesmo, mas vou buscar procurar algumas fontes para  fundamentar melhor. Achei interessante a discussão :)
Answer: O livro <code>Designing Web Interfaces</code> da Editora O'Reilly (focado somente em padrões de interface e em algumas "convenções" que visam fornecer uma melhor experiencia de usuário) "diz" que devemos limitar a quantidade de informações escondendo-a ou postergando sua aparição ao usuario (pois a grande quantidade de conteudo (seja em um form de cadastro ou de noticias) pode incomodar, desmotivar e até afugentar o usuário) para isso é mostrado o uso de alguns padrões visuais alguns citados abaixo:

Accordion: que limita a quantidade de conteúdo e opções visíveis ao usuário.
Dialog overlay: que foca a visão/concentração do usuário em um conteúdo especifio (pode ser uma informação relevante ou um formulário).
Detail Overlay: que mostra os detalhes de certo elemento quando o mesmo é focado pelo mouse.


Downgrade PHP 5.4 to 5.3 in Debian

Question: I had to do a Debian dist-upgrade on my server... in the process, PHP got upgraded to 5.4.  We use ioncube which only supports up to 5.3 atm, and I'm having some trouble finding how to downgrade to 5.3 from 5.4.  Anyone know how?
Comment: I certainly hope this doesn't mean you're using debian unstable (sid) on a server. Because that'd be a really, really, really bad idea.
Comment: Sid is named after the evil kid in Toy Story. He breaks toys. And servers.
Comment: I had to do a dist-upgrade to meet certain requirements for PCI compliance
Comment: If the packages.debian.com site is up-to-date (which I would believe that it is) then you must be on Debian Unstable. A dist-upgrade would not move you to a different release.
Comment: @duskwuff it's called unstable but it's not really unstable. In some occasions it may be better than the stable release. Obviously on a public server is not often the best solution, because it doesn't get fast security updates by the debian security team...
Comment: @dAm2K The whole point of sid/unstable is that it's where new packages go for testing. While it's *usually* not broken, there are no guarantees, and upgrading at the wrong moment *might* give you a broken system if you're unlucky. See http://www.debian.org/releases/sid/ for details.
Comment: I got it... it was simpler than I was making it. I had a sid reference in my sources list for some reason and that's what got php 5.4.  I removed that and added the wheezy sources and upgraded.  That fixed it.
Comment: "I had to do a dist-upgrade to meet certain requirements for PCI compliance"... and using an unstable distribution is good for PCI compliance?
Comment: @dAm2K: unstable does get speedy security updates these days, except for a short time (a month or so?) after a new release is promoted to stable so that isn't so much why you shouldn't use it in production. Updates go in there with relatively little testing compared to the other branches of course (as it exists in order to do some of that testing before updates are sent up the chain) which is why it isn't recommended for production use.
Answer: Neither of the solutions above worked for me. What did work was pinning the necessary packages to the old stable such as
Add the following to /etc/apt/sources.lst
deb http://ftp.us.debian.org/debian/ squeeze main contrib non-free
deb-src http://ftp.us.debian.org/debian/ squeeze main contrib non-free

Create
/etc/apt/preferences.d/preferences
And add the packages you need downgraded such as in my case
Package: php5*
Pin: release a=oldstable
Pin-Priority: 700

Package: libapache2-mod-php5
Pin: release a=oldstable
Pin-Priority: 700

Package: libapache2-mod-php5
Pin: release a=oldstable
Pin-Priority: 700

Package: php-pear
Pin: release a=oldstable
Pin-Priority: 700

Package: *
Pin: release a=stable
Pin-Priority: 600

Then run the commands
aptitude update
aptitude reinstall <necessary packages>
/etc/init.d/apache2 restart

If you want to know which packages you need to upgrade just run :
dpkg -l|grep php|grep 5.4|awk '{print $2}'

Comment: W: Failed to fetch http://ftp.us.debian.org/debian/dists/squeeze/main/source/Sources: 404  Not Found [IP: 2610:148:1f10:3::89 80]
Comment: You need to update the sources.list file with this now: `deb http://archive.debian.org/debian squeeze main contrib non-free
deb-src http://archive.debian.org/debian squeeze main contrib non-free`

See https://wiki.debian.org/DebianSqueeze
Answer: You could try this, but do it at your own risk. I didn't try it myself. ;)

apt-get remove php5
Download the PHP5 package from Stable
dpkg --force php5_5.3.3-7+squeeze8_all.deb
dpkg --set-selections PHP5 hold

The last line to prevent upgrading to 5.4. When you're ready for 5.4, run dpkg --set-selections PHP5 install
IonCube for 5.4 is a little while out from what I've read.
Comment: If you're still working on this, you should know that IonCube has been upgraded to work with PHP 5.4. Just stick with PHP 5.4 and download the latest IonCube libraries.
Comment: I've got this `dpkg: error: unknown force/refuse option 'php5_5.3.3-7+squeeze13_all.deb'`
Answer: You can install both php versions parallel e.g. PHP 5.5x and 5.3x or even three PHP versions parallel e.g. PHP 5.5x , 5.4x and 5.3x using fastcgi.
1. Install Libs, fastCGI, git
sudo apt-get update
sudo apt-get install build-essential
sudo apt-get install libxml2 libxml2-dev libssl-dev
sudo apt-get install libcurl4-openssl-dev pkg-config
sudo apt-get install libcurl4-gnutls-dev libjpeg-dev libpng12-dev libmysqlclient-dev

sudo apt-get install git
cd /opt
sudo git clone https://github.com/cweiske/phpfarm

sudo apt-get install libapache2-mod-fastcgi apache2-mpm-worker apache2-suexec
sudo a2enmod actions fastcgi suexec
sudo service apache2 restart

2. Compile PHP and verify it
cd /opt/phpfarm/src
sudo ./compile.sh 5.3.29
cd /opt/phpfarm/inst/bin
./php-5.3.29 --version

3. Configure FastCGI
sudo mkdir /var/www/cgi-bin
cd /var/www/cgi-bin
sudo nano php-cgi-5.3.29

#!/bin/sh
PHPRC="/etc/php5/cgi/5.3.29/"
export PHPRC
PHP_FCGI_CHILDREN=3
export PHP_FCGI_CHILDREN
PHP_FCGI_MAX_REQUESTS=5000
export PHP_FCGI_MAX_REQUESTS
exec /opt/phpfarm/inst/bin/php-cgi-5.3.29

Make this file executable.
4. Create a new virtual host
Put this into your host:
<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    ServerName fastcgidemo.dev
    DocumentRoot /var/www/fastcgidemo

    #php-cgi setup
    #used for multiple php versions
    FastCgiServer /var/www/cgi-bin/php-cgi-5.3.29
    ScriptAlias /cgi-bin-php/ /var/www/cgi-bin/

    <Directory "/var/www/fastcgidemo">
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Require all granted

            AddHandler php-cgi .php
            Action php-cgi /cgi-bin-php/php-cgi-5.3.29
            <FilesMatch "\.php$">
                SetHandler php-cgi
            </FilesMatch>
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/error_fastcgidemo.log
    CustomLog ${APACHE_LOG_DIR}/access_fastcgidemo.log combined
</VirtualHost>

Add the domains to /etc/hosts
127.0.0.1 fastcgidemo.dev

5. Test everything
Enable site and restart apache and create a new file with phpinfo() in /var/www/fastcgidemo to test your configuration.
Go to browser and type in fastcgidemo.dev
Hope it helps!
Full Tutorial on:
http://www.jabommi.de/wiki/downgrade-php-5-5-to-5-3-ubuntu-14-with-multiple-php-versions/
Answer: Downgrading PHP 5.4 to 5.3
First check which versions are supported for php5:
apt-cache showpkg php5

Here is the script which you could find it useful (it removes PHP 5.4 and install PHP 5.3):
sudo apt-get remove --purge `dpkg -l | grep php | grep -w 5.4 | awk '{print $2}' | xargs`
VERSION="php5_5.3.3-7+squeeze8_all" # CHANGES THIS WITH YOUR VERSION OF PACKAGE
sudo apt-get install php5=$VERSION php5-cli=$VERSION php5-common=$VERSION libapache2-mod-php5=$VERSION
sudo apt-get install php5=$VERSION php5-cli=$VERSION php5-common=$VERSION libapache2-mod-php5=$VERSION
sudo apt-get install php-pear=$VERSION php5-curl=$VERSION php5-gd=$VERSION php5-intl=$VERSION php5-mysql=$VERSION php5-pspell=$VERSION php5-recode=$VERSION php5-snmp=$VERSION php5-sqlite=$VERSION php5-tidy=$VERSION php5-xmlrpc=$VERSION php5-xsl=$VERSION

Where the available versions you can check by command: apt-cache showpkg php5
After the installation, verify it by command: php --version
Please be careful and don't install any other packages without package version specified (like php5-xcache), otherwise apt-get will replace your PHP instance with 5.4 again!
To prevent this happening, you can hold these packages.
Holding packages using dpkg
To hold packages by dpkg, you can execute the following command:
echo "php5 hold" | sudo dpkg --set-selections

To hold all PHP packages, run the following command:
dpkg --get-selections | grep ^php5 | sed s/install/hold/g | sudo dpkg --set-selections

The following command will show you holding status of your php packages:
sudo dpkg --get-selections | grep ^php

Holding packages using aptitude
You can also hold packages using aptitude e.g.:
sudo aptitude hold php5

Unhold:
sudo aptitude unhold php5

Extras
See also the same questions for Ubuntu, for some more ideas.
Answer: I would first look at what I have installed
dpkg -l |grep php

then uninstall any php that is version 5.4 example ...
apt-get remove libapache2-mod-php5 php-db php-pear php5 php5-cli php5-common

then you need to clean up the old files (not necessary but could help)
apt-get clean

then like above edit and pin
nano /etc/apt/preferences.d/preferences

if that still does not work repeat this but this time disable the repositories that are say wheeze and leave only the sid ones.
you could
apt-get install --reinstall

Answer: I had to do a full upgrade to wheezy by changing my apt sources to the wheezy sources.  Uninstalled php, upgraded the system with the new apt sources, installed php... everything's golden.
Comment: which sources you could at least post them. my apt sources doesn't have any php5.3 in there =/
Comment: Not an answer at all...

Downgrade PHP 5.4 to 5.3 in Debian


Como colocar a zero ou null numa pesquisa SQL de um intervalo de datas, para aquelas cujo valor não existe?

Question: Formula a questão foi um pouco difícil, mas tentarei ser o mais explícito possível usando um exemplo para expor a questão.
Existem os seguintes dados na minha tabela:

O objectivo é executar uma consulta sql (o SGBD utilizado é o MySQL) no intervalo de data entre 2014-09-01 até 2014-09-10 e ter o resultado seguinte:

O que já tenho:
Para ser sincero ando meio sem ideia de como fazer isso, até ao momento resolvo isso no controle da minha aplicação, um algoritimo como:

Selecionar os dados na BD, por meio de um between das datas desejadas e guardar numa lista;
Para cada dia (ou hora) existente no intervalo da data desejada, guardar em uma variável auxiliar(uma instância de Calendar em Java);
Verificar se Na lista obtida no ponto 1 existe um elemento com esta data, caso não haver, adiciono um elemento na lista resultante com esta data, mas zero no campo da quantidade;

Existe alguma forma de fazer isso já na consulta em sql? A forma como faço agora não é a mais eficiente.
Comment: Cold, você pode criar uma tabela com os períodos (só com datas), e fazer um `left join` com a tabela que você já usa.
Comment: @Wakim se trabalhar com largos intervalos de datas, terei de ter em paralelo uma tabela enorme só para guardar datas?
Comment: Você só precisa de um registro por dia. No pior caso, 3650 linhas para 10 anos. Terá que analisar se o ganho de performance vale a pena, podendo até utilizar um índice.
Comment: Eh... mais estariamos a considerar apenas dias, a minha realizadade são dados estatísticos de com uma precisão considerável : de 10 em 10 segundos. Uma query, a meu ver seia muito mais eficiente, consumiriamos apenas recursos quando necessário e não ocupar memoria física de forma permanente e ter que "joinar" sempre. Porém, se não surgir outra possibilidade, vou pensar em usar algo do género. Obrigado @Wakim
Answer: Você pode usar um gerador de datas para não precisar de tabelas intermediárias:
SELECT
   DATE_ADD( '2014-01-01', INTERVAL d1+d2*10+d3*100 DAY ) AS diaDoAno
FROM
   ( SELECT 0 AS d1 UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
     UNION SELECT 5 UNION SELECT 6 UNION SELECT 7 UNION SELECT 8 UNION SELECT 9 ) t1,
   ( SELECT 0 AS d2 UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
     UNION SELECT 5 UNION SELECT 6 UNION SELECT 7 UNION SELECT 8 UNION SELECT 9 ) t2,
   ( SELECT 0 AS d3 UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 ) t3
WHERE
   YEAR( DATE_ADD( '2014-01-01', INTERVAL d1+d2*10+d3*100 DAY ) ) = 2014

A query fica aparentemente grande, mas a performance é excelente.
Funcionamento:

Cada subquery gera os números de 0 a 9, exceto a última, que gera números de 0 a 3;
a fórmula d1+d2*10+d3*100 transforma as saídas das 3 subqueries em um número de 0 a 399
com DATE_ADD( '2014-01-01', INTERVAL d1+d2*10+d3*100 DAY ) transformamos este número em uma data.
Para limitar aos dias do ano em questão, usamos a mesma fórmula que gera a data, para assegurar que não passemos do intervalo de um ano (lembrando que o número de dias varia nos anos bissextos).

Como usar:
Conforme descrito em outras respostas, basta usar um JOIN com a tabela desejada.
SELECT
   DATE_ADD( '2014-01-01', INTERVAL d1+d2*10+d3*100 DAY ) AS dia_do_ano.
   contador,
   quantidade
FROM
   ( SELECT 0 AS d1 UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
     UNION SELECT 5 UNION SELECT 6 UNION SELECT 7 UNION SELECT 8 UNION SELECT 9 ) t1,
   ( SELECT 0 AS d2 UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
     UNION SELECT 5 UNION SELECT 6 UNION SELECT 7 UNION SELECT 8 UNION SELECT 9 ) t2,
   ( SELECT 0 AS d3 UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 ) t3
LEFT JOIN
    sua_tabela ON dia_do_ano = data_tempo
WHERE
    YEAR( DATE_ADD( '2014-01-01', INTERVAL d1+d2*10+d3*100 DAY ) ) = 2014

Obviamente que o exemplo foi complexo para gerar um ano inteiro, mas se for gerar meses do ano, por exemplo, basta algo como
SELECT 1 AS mes UNION SELECT 2 UNION SEL... até ...UNION SELECT 12

Answer: Cold.
Como o Wakin sugeriu e conforme eu estava escrevendo.
Faça uma tabela de datas, e à partir disto um LEFT JOIN com sua tabela.
Seguem dois links com sugestões para criação desta tabela:
Gerar Tabela Datas 1
Gerar Tabela Datas 2
Para os valores null, basta adicionar no seu COUNT a verificação IFNULL() e seu problema estará solucionado.
Comment: Obrigado @Fernando A.W. pela resposta/sugestão, porém, assim como falei ao wakin, eu teria de ter uma tabela(pelo semelhante a dimensão tempo num D.W) o que se calhar já não seria assim tão eficiente. Se não existir de facto outra forma de o fazer, vou considerar esta via.
Comment: Entendi, depende muito da sua arquitetura e necessidade. Mas se for uma tabela indexada e tudo mais, não seriam muitos registros para vincular, claro, vai depender muito do intervalo que você estaria buscando. Mas em paralelo a isto, você pode usar `hints` de performance para ajudar, segue um exemplo [Hint Performance](http://www.petefreitag.com/item/613.cfm). Fica como dica também. Mas creio que seja uma boa solução.
Answer: Você pode criar uma PROCEDURE criando uma tabela temporária antes de executar a consulta, por exemplo:
DELIMITER //
CREATE PROCEDURE TempDateTable(data_ini DATE, data_fim DATE)

BEGIN
    DECLARE v_curdate DATE;
    SET @v_curdate = data_ini;
    START TRANSACTION;
    DROP TABLE IF EXISTS tempdatetable;

    CREATE TEMPORARY TABLE tempdatetable  (
        data_tempo DATE NOT NULL PRIMARY KEY
    );

  WHILE @v_curdate <= data_fim DO
    INSERT INTO `TempDateTable`(`data_tempo`) VALUES (@v_curdate);
    SET @v_curdate = ADDDATE(@v_curdate, INTERVAL 1 DAY);
  END WHILE;
  COMMIT;
END//
DELIMITER ;

Dados
--------------------------------------
| data_tempo | contador | quantidade |
--------------------------------------
| 2014-09-01 | CDR_SUC  | 256        |
| 2014-09-04 | CDR_SUC  | 258        |
| 2014-09-05 | CDR_SUC  | 195        |
| 2014-09-06 | CDR_SUC  | 100        |
| 2014-09-10 | CDR_SUC  | 317        |
--------------------------------------

Executando Procedure
CALL `databasetest`.`TempDateTable`('2014-09-01', '2014-09-10');

Realizando a consulta
SELECT tmp.data_tempo, test.contador, IFNULL(test.quantidade,0)
FROM tempdatetable as tmp
    LEFT JOIN  testedados as  test ON DATE(test.data_tempo) = DATE(tmp.data_tempo);

Resultado:
--------------------------------------
| data_tempo | contador | quantidade |
--------------------------------------
| 2014-09-01 | CDR_SUC  | 256        |
| 2014-09-02 | NULL     | 0          |
| 2014-09-03 | NULL     | 0          |
| 2014-09-04 | CDR_SUC  | 258        |
| 2014-09-05 | CDR_SUC  | 195        |
| 2014-09-06 | CDR_SUC  | 100        |
| 2014-09-07 | NULL     | 0          |
| 2014-09-08 | NULL     | 0          |
| 2014-09-09 | NULL     | 0          |
| 2014-09-10 | CDR_SUC  | 317        |
--------------------------------------

Comment: Obrigado @KaduAmaral pela resposta, mas acredito que, assim como comentei com Fernando A.W. na resposta dele, eu estaria  a criar sempre uma dimensão de tempo (como num D.W.). E o mais incviavél para min seria ter uma dimensão auxiliar, ou seja, que é sempre criada quando for feita uma consulta. Para cada consulta eu tenho uma tabela criada com o tempo (em ordem de 10 segundos) com uns tantos registos...
Comment: E se não me engano o resultado aí é meio diferente do meu neh amigão... kkkkk. Só pra notar que os contadores podem diversificar.
Comment: A diferença que tu fala é o campo `contador`? Mas está tranquilo, se existe uma outra maneira de fazer isso, está além dos meus conhecimentos com SQL. Ou seja, que eu saiba só em algorítimo mesmo.
Comment: Pois é @KaduAmaral, porém já tenho esta opção como backup :D.


Como decompilar código de um módulo python usando marshal?

Question: Gostaria de obter o bytecode de um módulo em Python e salvar em um pyc com marshal.
Exemplo:
abc

test

module

t2

mod2

Então, eu faria import abc.test.module e gostaria de obter o bytecode e assim salvar um pyc dele, a partir disso.
Comment: Veja se isso pode te ajudar. É um descompilador para Python: https://github.com/wibiti/uncompyle2
Comment: @SamirBraga uncompyle deixa muitos arquivos mal decompilados e incompletos
Answer: Uma boa ferramenta, porém descontinuada é o UnPyc(suporta as versões 2.5 e 2.6 do Python). Há relatos que esse descompilador consegue recuperar cerca de 90% do arquivo original.
Também há o Easy Python Decompiler que é baseado em dois descompiladores(uncompyle2 e decompyle++). O interessante é que suporta desde a versão 1.0 até a 3.3 do Python.
De atenção também ao módulo py_compile.


Trouble with naming conventions in MVC

Question: I've always hated the scaffolding in MVC, so I decided to design my own Models, Views and Controllers. I have a model called CEmployee, a controller called ManageCEmployeeController, and a folder within the View folder called ManageCEmployee. The problem is that when I try to add a model inside the Index.cshtml file (which is in the previously mentioned folder) I get a few errors, which you can see here: https://i.stack.imgur.com/xAtHA.jpg
According to some stuff I've found online, I've fulfilled all the conventions.
Any ideas?
Answer: Judging by your header tag I am going to say that you are wanting to list some data from your datasource. @using EmployeesTracking.Models is fine but you are going to provide a list to this view. You need to let the view know you are fixing to throw a list of data at it by declaring
     @using System.Collections.Generic;
     @using EmployeesTracking.Models;
     @model IEnumerable<CEmployees>;

IEnumerable is a list of data. This tells the view that the controller has already looked at your model class CEmployee and has a list of data ready to display.
Now I know you said you didn't like the scaffolding, but it is a great way to get started and you can simply take out what you don't want real easy.
Comment: Huh? How did you _infer_ all of that from the post? There is no problem with `@model CEmployee` based on what is in the question or image.
Comment: When you use scaffolding and it builds a "list" view it uses a heading of List . In his code you will see this at the bottom. If you are going to render a list it has to be an IEnumerable <>, ICollection <>, or IList <>. I use scaffolding a lot so I noticed this right away. Also he is using index.chtml as the view name which is also the standard name scaffolding gives the "list" view. It requires an IEnumurable collection from the model. I am assuming he is using code he is familiar with when he did use scaffolding
Answer: Remove the semi-colon (;) from your @model declaration:
@using System.Collections.Generic;
@using EmployeesTracking.Models;

//No semi-colon terminator needed...
@model CEmployee

Hth...

Trouble with naming conventions in MVC


How do I hook before the user is created in Behat tests?

Question: I have a Behat test where I have a Given user step, and I want to alter some fields (token replacements). Which Behat hook should I use? I know that for Given content, the Behat hook would be @beforeNodeCreate.
Which hook is for users?
Answer: Somewhat predictably, which I'm pretty sure is deliberate, it's <code>@beforeUserCreate</code>.
The Drupal Extension Hooks section of the docs has a bit of background in case you need it.


Animar o texto de um textView de forma a ser exibido progressivamente?

Question: Gostaria que o texto da textView presente na minha activity não fosse exibido todo de uma vez, mas aos poucos, algo como uma transição do Power Point.
Um exemplo do que quero fazer exatamente seria textos de diálogos dos jogos de pokémon de GBA VEJA A PARTIR DE 1:33 não necessariamente um caractere de cada vez como exibido no vídeo, mas uma palavra de cada vez até o fim do texto.
Gostaria de saber se tem como limitar o tempo total da escrita do texto, de modo que se o limite imposto for ultrapassado, o restante do texto seja todo escrito instantaneamente (para textos muito longos).
activity:

package genesysgeneration.font;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    private TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(android.R.layout.activity_list_item);

        tv=(TextView)findViewById(R.id.tv);
        tv.setText("Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográfica e de impressos, e vem sendo utilizado desde o século XVI, quando um impressor desconhecido pegou uma bandeja de tipos e os embaralhou para fazer um livro de modelos de tipos. Lorem Ipsum sobreviveu não só a cinco séculos, como também ao salto para a editoração eletrônica, permanecendo essencialmente inalterado. Se popularizou na década de 60, quando a Letraset lançou decalques contendo passagens de Lorem Ipsum, e mais recentemente quando passou a ser integrado a softwares de editoração eletrônica como Aldus PageMaker.");

    }
}

xml:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin">

    <TextView
        android:id="@+id/tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</RelativeLayout>

Edit:
Tentei o sugerido por @Mr_Anderson, porém não obtive sucesso.
Vária linhas apresentaram erros:

MainActivity:

package genesysgeneration.pokemaos;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TypeWriter t = (TypeWriter)findViewById(R.id.meuTxt);
        t.setCharacterDelay(100);
        t.animateText("Olha só");

    }
}

Class:

package genesysgeneration.pokemaos;

import android.content.Context;
import android.util.AttributeSet;
import android.widget.TextView;
import java.util.logging.Handler;

public class TypeWriter extends TextView {

    private CharSequence mText;
    private int mIndex;
    private long mDelay = 500;

    public TypeWriter(Context context){

        super(context);

    }

    public TypeWriter(Context context, AttributeSet attrs){

        super(context, attrs);

    }

    private Handler mHandler = new Handler();
    private Runnable characterAdder = new Runnable() {
        @Override
        public void run() {
            setText(mText.subSequence(0, mIndex++));
            if (mIndex<=mText.length()){

                mHandler.postDelayed(characterAdder, mDelay);

            }
        }
    };

    public void animateText(CharSequence text){

        mText=text;
        mIndex=0;

        setText("");
        mHandler.removeCallbacks(characterAdder);
        mHandler.postDelayed(characterAdder, mDelay);

    }

    public void setCharacterDelay(long millis){

        mDelay=millis;

    }

}

xml:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="genesysgeneration.pokemaos.MainActivity">

    <TextView
        android:id="@+id/tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <com.Pokemaos.view.custom.TypeWriter

        android:id="@+id/meuTxt"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</RelativeLayout>
Comment: Você pode usar essa resposta como fonte: http://stackoverflow.com/questions/6700374/android-character-by-character-display-text-animation
Answer: Recorrendo ao Property animation system(Sistema de animação de propriedades) do SDK é possível conseguir o efeito que pretende.
Esta abordagem permite ter de "borla" todas as funcionalidades do sistema de animação como pause/resume, reverse, repeat, animator listener e update listener.
Escreva um wrapper sobre um ValueAnimator em conjunto com um TimeInterpolator e dois TypeEvaluator.
O TimeInterpolator é usado para calcular o número de letras ou número de palavras que o texto deve ter num determinado instante da animação.
Os ValueAnimator usam o valor calculado pelo TimeInterpolator para determinar a parte do texto que deve ser apresentada nesse instante da animação.
TextViewAnimator.java
public class TextViewAnimator {

    private TextValueAnimator textValueAnimator;

    public static TextViewAnimator perLetter(TextView textView){

        int steps = textView.getText().length();
        TextViewAnimator textViewAnimator =
                new TextViewAnimator(textView,
                                     new TextEvaluatorPerLetter(),
                                     new TextInterpolator(steps));
        return textViewAnimator;
    }

    public static TextViewAnimator perWord(TextView textView){

        int steps = textView.getText().toString().split(" ").length;

        TextViewAnimator textViewAnimator =
                new TextViewAnimator(textView,
                                     new TextEvaluatorPerWord(),
                                     new TextInterpolator(steps));
        return textViewAnimator;
    }

    public TextViewAnimator(TextView textView,
                            TypeEvaluator typeEvaluator,
                            TextInterpolator textInterpolator){

        this.textValueAnimator = new TextValueAnimator(textView, textView.getText().toString());
        textValueAnimator.setEvaluator(typeEvaluator);
        textValueAnimator.setInterpolator(textInterpolator);
    }

    private static class TextValueAnimator extends ValueAnimator implements ValueAnimator.AnimatorUpdateListener {

        private WeakReference<TextView> weakTextView;

        public TextValueAnimator(TextView textView, String text) {

            weakTextView = new WeakReference<>(textView);
            setObjectValues(text);
            addUpdateListener(this);
        }

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            String text = (String) animation.getAnimatedValue();
            TextView textView = weakTextView.get();
            if(textView != null) {
                textView.setText(text);
            }
        }
    }

    private static class TextEvaluatorPerLetter implements TypeEvaluator {

        @Override
        public Object evaluate(float fraction, Object startValue, Object endValue) {
            int step = (int) fraction;
            return ((String) endValue).substring(0, step);
        }
    }

    private static class TextEvaluatorPerWord implements TypeEvaluator {

        private String[] words;
        @Override
        public Object evaluate(float fraction, Object startValue, Object endValue) {

            int step = (int) fraction;
            if(words == null){
                words = ((String) endValue).split(" ");
            }
            String textAtStep = "";
            for (int i = 1; i <= step; i++) {
                textAtStep += words[i-1] + " ";
            }

            return textAtStep;
        }
    }

    private static class TextInterpolator implements TimeInterpolator {

        private int steps;
        public TextInterpolator(int steps) {

            this.steps = steps;
        }
        @Override
        public float getInterpolation(float input) {
            return input * steps;
        }
    }

    public void start(){
        textValueAnimator.start();
    }
    public void cancel(){
        textValueAnimator.cancel();
    }
    public void end(){
        textValueAnimator.end();
    }

    @RequiresApi(19)
    public void pause(){
        textValueAnimator.pause();
    }
    @RequiresApi(19)
    public void resume(){
        textValueAnimator.resume();
    }
    @RequiresApi(19)
    public boolean isStarted(){
        return textValueAnimator.isStarted();
    }
    @RequiresApi(19)
    public float getAnimatedFraction(){
        return textValueAnimator.getAnimatedFraction();
    }
    public void setRepeatCount(int value){
        textValueAnimator.setRepeatCount(value);
    }
    public void setRepeatMode(int repeatMode){
        textValueAnimator.setRepeatMode(repeatMode);
    }
    public void setDuration(long duration){
        textValueAnimator.setDuration(duration);
    }
    public void setStartDelay(long startDelay){
        textValueAnimator.setStartDelay(startDelay);
    }
    public void addUpdateListener(ValueAnimator.AnimatorUpdateListener listener){
        textValueAnimator.addUpdateListener(listener);
    }
    public void removeUpdateListener(ValueAnimator.AnimatorUpdateListener listener){
        textValueAnimator.removeUpdateListener(listener);
    }
    public boolean isRunning(){
        return textValueAnimator.isRunning();
    }
    public void addListener(Animator.AnimatorListener listener){
        textValueAnimator.addListener(listener);
    }
    public void removeListener(Animator.AnimatorListener listener){
        textValueAnimator.removeListener(listener);
    }
}

A classe disponibiliza dois factory methods:

TextViewAnimator.perLetter().
Retorna um TextViewAnimator que anima o texto, previamente atribuído ao TextView, letra por letra.
TextViewAnimator.perWord().
Retorna um TextViewAnimator que anima o texto, previamente atribuído ao TextView, palavra por palavra.

A escolha de um "wrapper" para a implementação, em vez de herança, deve-se à necessidade de "esconder" alguns dos métodos públicos da classe ValueAnimator.
Exemplo de utilização de animação letra por letra:
public class MainActivity extends AppCompatActivity {

    TextView textView;
    Button button;
    TextViewAnimator textViewAnimator;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = (TextView) findViewById(R.id.text1);

        textViewAnimator = TextViewAnimator.perLetter(textView);
        textViewAnimator.setDuration(5000);
        textViewAnimator.setRepeatCount(2);
        textViewAnimator.setRepeatMode(ValueAnimator.REVERSE);

        button = (Button)findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                textViewAnimator.start();
            }
        });
    }
}

O layout da Activity(activity_main.xml) deverá ter um Button e um TextView com id's "@+id/button"e "@+id/text1" respectivamente.
Notas:
 - Requer minSdkVersion 11.
 - Alguns métodos requerem minSdkVersion 19.
Comment: Esqueceu de comentar sobre a versão mínima do SDK, no qual funcionará essa classe.
Comment: @AckLay Esse comportamento foi introduzido propositadamente no  exemplo da resposta para demonstrar uma da várias possibilidades de animação. Ele é obtido pelas linhas `textViewAnimator.setRepeatCount(2);` e `textViewAnimator.setRepeatMode(ValueAnimator.REVERSE);`. Elimine-as para o texto ser escrito uma só vez. Não entendi o que quer com a referência em relação ao `pause()`.
Comment: Ué, te enviei o link focando exatamente o método `pause()`. Achei que você iria olhar no canto direito. Desculpa! xD
Comment: Olha o que encontrei: https://developer.android.com/reference/android/animation/ValueAnimator.html#pause()

Outra coisa: Observei que o texto é escrito até o fim e depois volta apagando novamente até completar o tempo máximo definido. ps.: só estou ajudando na qualidade da resposta.
Comment: @AckLay Descobri porque falou no `onPause()`. Você podia ter dito logo que necessitava da API19 :)
Answer: Você vai criar uma classe que é uma view customizada
public class Typewriter extends TextView {

    private CharSequence mText;
    private int mIndex;
    private long mDelay = 500; //Default 500ms delay

    public Typewriter(Context context) {
        super(context);
    }

    public Typewriter(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    private Handler mHandler = new Handler();
    private Runnable characterAdder = new Runnable() {
        @Override
        public void run() {
            setText(mText.subSequence(0, mIndex++));
            if(mIndex <= mText.length()) {
                mHandler.postDelayed(characterAdder, mDelay);
            }
        }
    };

    public void animateText(CharSequence text) {
        mText = text;
        mIndex = 0;

        setText("");
        mHandler.removeCallbacks(characterAdder);
        mHandler.postDelayed(characterAdder, mDelay);
    }

    public void setCharacterDelay(long millis) {
        mDelay = millis;
    }
}

Depois usa ela no xml activity_main (Editado)
<genesysgeneration.pokemaos.Typewriter
        android:id="@+id/meuTxt"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

Depois é só instanciar na MainActivity
Typewriter t = (Typewriter) findViewById(R.id.meuTxt);
t.setCharacterDelay(100);
t.animateText("Olha só que legal");

Comment: no xml da mainActivity?
Comment: No seu código, você importou o Handler errado. Use o import correto: import android.os.Handler;
Na hora de usar o widget no xml activity_main, só digite <Typewriter e dê um enter que o Android studio vai auto-completar com o pacote na qual você criou sua classe Typewriter, que é o genesysgeneration.pokemaos
Comment: Editei o xml da resposta...
Comment: sussa, agora a seguinte linha continua acusando erro `public class TypeWriter extends TextView {` mais especificamente o extends TextView.
Comment: Bem, mesmo acusando esse erro, roda tudo de boa, mas não estou conseguindo fazer com que minha textView exiba esse animated text, além disso tudo o mais que tem na activity some!!!
Comment: Use um texto maior... Talvez a animação de um texto curto demais acabe rápido demais e não dê a impressão de estar sendo "teclado" aos poucos.
Comment: nn, a impressão de que esta sendo digitado acontece, o problema é que todo o restante da activity some
Comment: Pode postar o xml do da sua activity?
Você se certificou de ajustar o layout_width e o layout_height de acordo com a sua necessidade? Certificou-se de que ambos não estão com match_parent?
Comment: Tudo certo, único problema continua sendo somente o erro que é acusado na seguinte linha: `public class Typewriter extends TextView {`, de qualquer forma ele não impede a aplicação de ser executada corretamente
Comment: Certo. Aqui também ocorre. Você pode dar alt+enter que o Android studio vai pedir para que você estenda de AppCompatTextView ao invés de um TextView. Pelo que li, ele pede isso para que seu textView, se executado em APIs baixas, suporte métodos que somente funcionariam em APIs mais recentes...
Comment: Hey e como fazer para executar uma ação assim que ele for finalizado?
Answer: Apesar do Ramaral ter dado uma resposta válida, pensei de uma outra forma no qual funciona para qualquer versão do Android.
Basicamente uso o Runnanble com um delay concatenando letra por letra ou palavra por palavra.

animPerLetter(): letra por letra
animPerWord(): palavra por palavra

MainActivity:
TextAnimatedView textAnimatedView = (TextAnimatedView) findViewById(R.id.tv);
textAnimatedView.setCharacterDelay(150);
textAnimatedView.animPerWord("Desta forma vai funcionar como esperado");

No XML você usa desta forma abaixo:
<seu.pacote.TextAnimatedView
    android:id="@+id/tv"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"/>

Veja abaixo como ficou a classe TextAnimatedView:
public class TextAnimatedView extends TextView {

    private Handler handler = new Handler();
    private StringBuilder stringBuilder = new StringBuilder();
    private CharSequence text;
    private String[] arr;
    private int i;
    private long delay = 450;

    public TextAnimatedView(Context context) {
        super(context);
    }

    public TextAnimatedView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            setText(text.subSequence(0, i++));
            if (i <= text.length()) {
                handler.postDelayed(runnable, delay);
            }
        }
    };

    public void animPerLetter(CharSequence text) {
        this.text = text;
        i = 0;

        setText("");
        handler.removeCallbacks(runnable);
        handler.postDelayed(runnable, delay);
    }

    private Runnable runnablePerWord = new Runnable() {
        @Override
        public void run() {

            stringBuilder.append(arr[i++]).append(" ");
            setText(stringBuilder.toString());
            if (i < arr.length) {
                handler.postDelayed(runnablePerWord, delay);
            }
        }
    };

    public void animPerWord(CharSequence text) {
        this.text = text;
        i = 0;

        setText("");
        arr = text.toString().split(" ");
        handler.removeCallbacks(runnablePerWord);
        handler.postDelayed(runnablePerWord, delay);
    }

    public void setCharacterDelay(long delay) {
        this.delay = delay;
    }
}

Um GIF vale mais que mil imagens.
Comment: @ramaral quando tem-se complementação de alguma outra resposta, você edita a resposta do usuário ou você cria uma nova? Foquei na parte que o AP pergunta "[...]não necessariamente um caractere de cada vez como exibido no vídeo, mas uma palavra de cada vez até o fim do texto.[...]". Na minha opinião, digo na minha opinião, sua resposta não atende esse requisito da pergunta.
Comment: @ramaral importante é ajudar, aprendendo. =)
Comment: Essa é idêntica à resposta do Mr_Anderson.
Comment: A sua resposta é válida. Não quis dizer que não devia responder, foi apenas uma observação. O exemplo que ele dá é letra a letra, apenas refere que não precisa de ser assim, que pode ser palavra a palavra.