Os limões lançados por Saul Alinsky e uma receita de limonada para a direita

8
146

work.4500484.1.flat550x550075f.when-life-gives-you-lemons-make-lemonade-e1313394268954

No início de setembro fiz um post divulgando o excelente trabalho de Sílvio Medeiros ao avaliar o livro “A Arte da Guerra Política”, de David Horowitz, em uma palestra na PUC. Um trabalho estupendo! Agora, ele de novo dá um tiro certeiro ao avaliar o livro “Rules for Radicals”, de Saul Alinsky, em uma nova palestra na PUC, cujo vídeo está no final deste post.

Ambas as palestras tem aproximadamente 100 minutos cada. Digo sem medo de errar: vale a pena “perder” uma tarde inteira assistindo os dois vídeos. Ou você prefere assistir G.I. Joe 2 ou Velozes e Furiosos 6? Ok, ok… eu também assisto filmes ruins (especialmente de ação), mas se você consegue gastar 100 minutos de sua vida assistindo um filme ruim, pode gastar o mesmo tempo assistindo algo que vai te melhorar em termos políticos.

Há mais de um ano eu havia publicado a tradução de “A Arte da Guerra Política”, de David Horowitz, e um ensaio sobre o livro de Saul Alinsky (ambos na sessão “Séries”, deste blog). Assim como no caso da palestra sobre Horowitz, posso dizer que ambos os vídeos de Medeiros são ótimos complementos à leitura deste material, pelos ótimos exemplos que ele traz.

Medeiros, por exemplo, nos lembra da similaridade das práticas dos petistas, em total apoio aos mensaleiros (invertendo toda a moral que conhecemos), com aquilo que Alinsky defende como método. Sem exagero, podemos dizer que se entendermos Saul Alinsky, entenderemos o padrão de pensamento da esquerda atual. E conhecer o inimigo é o primeiro passo para tentar derrotá-lo.

Medeiros dá uma ênfase na análise da personalidade e dos objetivos de Alinsky, dando um espaço relativamente pequeno às técnicas alinskianas. Talvez essa seja a única ressalva que eu faria quanto à palestra, pois ao final fica um aspecto melancólico (um dos participantes da audiência usa a expressão “é muito triste” mais de uma vez).

Talvez pelo meu histórico focado em auditorias corporativas, não consigo sentir essa sensação (que, em muitos casos, parece nos estimular ao desânimo ou impotência – embora eu não diga que esse seja o caso de Medeiros, que fique bem claro). Em meu paradigma, automaticamente entendo que conhecer os métodos e princípios do inimigo (por mais podres que sejam esses princípios) funciona como um estímulo para o desenvolvimento de contra-medidas contra esse inimigo. Quanto mais sujo e imoral é um fraudador, e quanto mais dano ele pode causar, mais surge um gostinho especial em desmascarar suas fraudes. Eis minha heurística: se é assim que auditores pensam no mundo corporativo, por que não usar aquilo que sempre funciona por lá também no debate político?

Isso talvez explique minha interpretação mais ampla e pragmática das regras para táticas 2 e 3 de Alinsky, que dizem, respectivamente: (2) Nunca vá além da experiência de sua comunidade; (3) Sempre que possível, fuja da experiência do seu inimigo.

Em minha interpretação isso significa buscar fazer aquilo que somos melhores em fazer, usando abordagens que dominamos mais, e, preferencialmente, que sejam abordagens que meu oponente não domina, e para as quais as reações deles não serão as melhores. No mundo corporativo, fraudadores são bons em fazer fraudes. Auditores são bons em achar fraudes. Cada um que fique em seu domínio de experiência, e é assim que as coisas funcionam melhor. É praticamente uma dinâmica social.

Em outras palavras, isso significa entender que se é um fato que esquerdistas (especialmente os da extrema-esquerda) tomam a mentira como um princípio, não podemos nos especializar na mesma coisa, pois a mentira para nós não é um princípio. Não é nosso expertise. É o expertise deles! Mas podemos escolher uma ação que se coadune com os nossos princípios (nos quais valorizamos uma moral absoluta, seja ela secular ou religiosa, seja ela oriunda de revelação ou discutida em termos científicos) e na qual o nosso oponente não é tão bom.

Posso dizer que por inspiração alinskiana, eu desenvolvi de forma mais detalhada meu paradigma de ceticismo político, no qual eu defendo que devemos nos tornar especialistas em investigação e denunciação de fraudes de nosso oponente (pois esta é uma prática que nós vamos gostar de fazer, pois valorizamos uma moral absoluta, que foge do relativismo moral). Estou saindo da experiência de meu inimigo, e permanecendo em nossa experiência.

Desta feita, Alinsky é visto por mim como uma fonte de inspiração (não por seus princípios morais, obviamente, mas por suas táticas). Eu e Alinsky somos oponentes em princípios, mas similares nas principais táticas. Ao invés de ficar indignado ou irritado, li o livro “Regras Para Radicais” com empolgação (a obra tem quase 200 páginas, e a li em 2 dias, de forma detalhada, e sem apelar à leitura dinâmica). Isto é, me jogaram um limão e eu fiz uma limonada. Parece até ditado de auto-ajuda, mas é pura reconstrução política 😉

Aqueles que conheçam tanto o material de David Horowitz como o de Saul Alinsky, e tenham absorvido o conteúdo (e Medeiros pode lhe dar um bom empurrão nesse sentido), se tornam pessoas mais aptas a adquirir, enfim, uma consciência política para a direita, de forma finalmente pensar em combater a esquerda.

Eis o guideline de estudos que proponho:

  1. Ler “A Arte da Guerra Política”, de David Horowitz
  2. Assistir o vídeo com a palestra de Silvio Medeiros, para absorver melhor o conteúdo. Segue o link de novo.
  3. Ler o ensaio “Um Raio X das Regras Para Radicais de Saul Alinsky”, que publiquei ano passado. Eis os capitulos:
  4. Assistir, enfim, o vídeo com a palestra de Medeiros de que falei, conforme abaixo:
Anúncios

8 COMMENTS

  1. What fuck is going on?

    Why the video was removed?

    void main() {
    class luciano.stream {
    method-no-way( char empty_video);
    int property-no-video = 1;
    };
    exit (no_funny);
    }

    Bye.eee

  2. Forget about C, think D.

    // ($ax$) (axhello.d) (module ax.axhello)

    import std.stdio;
    import std.cstream;
    import std.conv;

    void main(string[] args)
    {
    // Primus part – Hello World.
    writeln(“Hello World!”);
    writefln(“args.length = %s”, args.length);
    foreach (int index, string arg; args) {
    writefln(“args[%s] = ‘%s'”, index, arg);
    }
    writeln();

    /* foreach (index, arg; args) {
    * writeln(“args[“, index, “] = ‘”, arg, “‘”);
    * }
    */

    // writeln(“Welcome to my D.Program!”);
    displayDataTypes();

    // computeHeights();
    // waitEnter();
    // displayResult(askInt() + askInt());
    }

    // Print out information about data types.
    void displayDataTypes()
    {
    // Print out information about integer types.
    writefln(” bool stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d):(%s..%s)\n”,
    bool.stringof, bool.sizeof, (bool.sizeof * 8), bool.min, bool.max, bool.min, bool.max);
    writefln(” byte stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)”,
    byte.stringof, byte.sizeof, (byte.sizeof * 8), byte.min, byte.max);
    writefln(” ubyte stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)\n”,
    ubyte.stringof, ubyte.sizeof, (ubyte.sizeof * 8), ubyte.min, ubyte.max);
    writefln(” short stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)”,
    short.stringof, short.sizeof, (short.sizeof * 8), short.min, short.max);
    writefln(” ushort stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)\n”,
    ushort.stringof, ushort.sizeof, (ushort.sizeof * 8), ushort.min, ushort.max);
    writefln(” int stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)”,
    int.stringof, int.sizeof, (int.sizeof * 8), int.min, int.max);
    writefln(” uint stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)\n”,
    uint.stringof, uint.sizeof, (uint.sizeof * 8), uint.min, uint.max);
    writefln(” long stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)”,
    long.stringof, long.sizeof, (long.sizeof * 8), long.min, long.max);
    writefln(” ulong stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)\n”,
    ulong.stringof, ulong.sizeof, (ulong.sizeof * 8), ulong.min, ulong.max);

    // Show information about size_t type.
    writefln(” size_t stringof:(%6s) sizeof:(%d):(%d) min..max:(%d..%d)\n”,
    size_t.stringof, size_t.sizeof, (size_t.sizeof * 8), size_t.min, size_t.max);

    // Show information about floating-point types.
    // writefln(“(%d) float\t(%d) double\t(%d) real\n”, float.sizeof, double.sizeof, real.sizeof);
    writefln(” float stringof:(%6s) sizeof:(%d):(%d)”,
    float.stringof, float.sizeof, (float.sizeof * 8));
    writefln(” double stringof:(%6s) sizeof:(%d):(%d)”,
    double.stringof, double.sizeof, (double.sizeof * 8));
    writefln(” real stringof:(%6s) sizeof:(%d):(%d)\n”,
    real.stringof, real.sizeof, (real.sizeof * 8));

    // Show information about character types.
    // writefln(“(%d) char\t(%d) wchar\t(%d) dchar”, char.sizeof, wchar.sizeof, dchar.sizeof);
    writefln(” char stringof:(%6s) sizeof:(%d):(%d)”,
    char.stringof, char.sizeof, (char.sizeof * 8));
    writefln(” wchar stringof:(%6s) sizeof:(%d):(%d)”,
    wchar.stringof, wchar.sizeof, (wchar.sizeof * 8));
    writefln(” dchar stringof:(%6s) sizeof:(%d):(%d)\n”,
    dchar.stringof, dchar.sizeof, (dchar.sizeof * 8));
    }

    /* Compute heights from feets’inches” to centimeters.
    * Compute heights in centimeters, for a range
    * of heights expressed in feets and inches.
    */
    void computeHeights()
    {
    // Values unlikely to change soon.
    immutable int inchPerFoot = 12;
    // immutable inchPerFoot = 12;
    immutable double cmPerInch = 2.54;
    // immutable cmPerInch = 2.54;
    // Loop’n write.
    writeln(“Display Feets’Inches” to Centimeters.”);
    foreach (int feet; 0..2) {
    // foreach (feet; 0..2) {
    foreach (double inches; 0..inchPerFoot) {
    // foreach (inches; 0..inchPerFoot) {
    writefln(“%s’%s”\t%s”, feet, inches, (((feet * inchPerFoot) + inches) * cmPerInch));
    }
    }
    }

    // Wait for user to press enter.
    void waitEnter()
    {
    write(“Press enter to continue…”);
    din.readLine();
    }

    // Display result.
    void displayResult(int result)
    {
    writefln(“The answer is %d”, result);
    }

    // Ask for an integer from user and return it.
    int askInt()
    {
    char[] line;
    int num;
    write(“Enter an integer: “);
    line = din.readLine();
    num = std.conv.to!int(line);
    // num = to!int(line);
    return num;
    }

    Bye.eee

  3. Ayan, num foco mais prático, qual seria a tática para neutralizar aquele ataque, citado no vídeo, feito contra o Bush pai? Você tem essa visão prática, eu não tive grandes ideias, a única coisa que pensei seria ter um assessor negro (provavelmente ele não tinha) e colocá-lo pra continuar a palestra. Quais seriam boas soluções pra neutralizar um ataque tão pesado?

    • Acho que o problema relativo ao Tubby foi o fato dos criadores insistirem num modelo obsoleto de Tubby Catódico, que sabidamente é emissor de radiação e prejudicial aos olhos.

      Acredito que o pessoal do software irá adequar o Tubby a um modelo Tubby Led Matricial, e então o produto poderá ser liberado, tão logo possa ser devidamente entubado.

      Abraços a todos e aguardemos o desentubamento do Tubby.

Deixe uma resposta