Microsoft Academic Day 2009 - RJ

Twittando direto do auditório Roxinha da UFRJ =D
www.twitter.com/brunobuss

Programação do evento:
http://www.dcc.ufrj.br/~brunobuss/ms_ac2009.pdf

Migrando repositórios SVN para GIT

Resolvi migrar dois projetos do Google Code, que estão guardados em repositórios SVN para repositórios GIT e armazena-los no GitHub.

Os dois projetos em questão, foram projetos feitos em grupo para a faculdade e que pararam completamente de serem desenvolvidos logo após a entrega (novidade :P), na verdade um deles nem chegou a ser concluído (eu disse para não fazer em Java...).

Como o Google Code limita o número de projetos que você pode ter e estes estão apenas ocupando espaço, resolvi migra-los.


Realmente é muito facil, bastou apenas:
a) Criar um arquivo - que chamei de 'authors' - com as seguintes informacões de todo mundo que já tinha feito commit no svn:
nomedousuario = Nome Completo

Ai ficou algo do tipo:
"bruno.buss = Bruno Caricchio Buss
..."

b) Fazer um: git svn clone --authors-file=authors http://seuprojeto.googlecode.com/svn/trunk.

Molezinha!

Inclusive ja subi os 2 para o GitHub:
LojaSim: https://github.com/brunobuss/lojasim/tree
Piscemu: https://github.com/brunobuss/piscemu/tree

Para quem quiser ver mais informacões de como trabalhar com svn e git juntos, a documentação do git-svn é muito boa:
http://www.kernel.org/pub/software/scm/git/docs/v1.6.0.6/git-svn.html

(Essa documentação não é a da última versão do git, mas da versão que tem no Fedora 10).

PS: Apesar de depois de fazer o primeiro descobrir que o GitHub faz import de repos públicos de svn... fiz na mão mesmo :P

Tentando ficar online de novo....

Não que eu não tenha estado online... somente sem tempo/disposição para postar nada aqui.


Normalmente eu estava postando apenas no meu twitter, esse negócio de microblogging é legal quando você não tá afim de realmente escrever, como aqui estou agora :P


Esse período na faculdade foi *TENSO*, fica a dica... nunca puxem 8 matérias (31 créditos =X). Sério, foi algo insano (e que ainda não acabou... mas está no finalzinho).


Muitas das matérias também não ajudaram o que acabou me desempolgando sériamente durante o período, mas entre mortos e feridos todos se salvaram.


Mas também tiveram coisas legais que fiz e gostaria de ter postado aqui sobre o desenvolvimento delas e como foram progredindo... mas não deu :P

Enfim, finalmente fiz um projeto em QT. Um não, dois! \o/
(E não fui só eu claro, foi meu grupo =)

Um deles foi um jogo para a disciplina de Inteligência Artificial. Um Othello (aka Reversi) que utiliza o Min-Max como algoritmo para a IA.
Esse projeto utilizou QT basicamente para fazer a GUI.

Vocês podem conferir o grandOthello aqui:
http://code.google.com/p/grandothello/

Outro foi um projeto para a disciplina de Sistemas Operacionais, que fazia uma simulação de uma loja (é, eu também não gostei muito não...). Nesse utilizamos somente a parte do QTCore, para podermos fazer uma aplicação Multi-thread, utilizar memória compartilhada entre threads e semáforos para sincronização e exclusão mútua, tudo rodando em sistemas Win32 e Linux sem nenhuma alteração no código =D

Iríamos fazer uma GUI também, mas acabou que não deu tempo =/

O repositório do projeto está aqui, mas provavelmente como não faremos mais nada com ele, na melhor da hipóteses eu irei passa-lo para o meu GitHub:
http://code.google.com/p/lojasim/


Consegui tirar um incrível 9.5 (perdi 0.5 porque não fiz uma questão :P) na Prova Final de Física 3... e acreditem foi uma façanha para mim, acabei conseguindo passar com 7.4.



Voltei a mexer um pouco com Perl, para começar a brincar com Catalyst... e ele é estranho, pois é complicado e simples ao mesmo tempo.


Anyway... vamos ver se nessas 2/3 semanas de "férias" eu consigo voltar a postar no blog =]

É a hora da verdade... e como ficou a minha lista de coisas a fazer em 2008?

É pessoal... faltando 3 dias para o novo ano (ou ano novo :P), resolvi verificar a minha lista de coisas que eu gostaria de ter feito em 2008 e ver o que eu fiz, o que fiz mais ou menos ou o que chutei de vez :P

Para cada coisa eu irei me dar uma pontuação:
+1 => se eu fiz direitinho
0 => se eu fiz mais ou menos
-1 => se nem com muita boa vontade da para salvar :P

Então, here we go:

1 - Estudar (aprender ou me aprofundar em) as seguintes linguagens de programação: Perl, C/C++, C# e Assembly. De todas as existentes, quero dar mais ênfase nestas 4 este ano.

Vixe... acho que vou começar mal aqui.
Perl: Apesar de ter programado uma coisa ou outra... foi muita coisa no estilo "preciso de algo rápido para resolver um treco". Um dos casos foi quando fiz um programa em Perl para automatizar uns testes de alguns programas que rodaram em paralelo utilizando PVM, MPI e OpenMP.

C/C++: Bem... talvez a parte de C++ tenha sido a menos pior. Acabei estudando um pouquinho mais de C++ por alguns motivos... mas sinceramente, nada que eu considere perto de "estudo" mesmo.

C#: Não escrevi 1 linha de código. Nada...

Asm: O máximo que fiz, foi ler os programas da Taísa :P

Então... neste ponto eu estou me dando um -1.

Subtotal: -1.

2 - Elevar meu CRA na faculdade para > 8. Sim, não está dos piores, 7.7. Mas quero subir ele para acima de 8.

Err... vamos lá.
Em 2008-1 se não fosse a maldita Física 3, eu teria conseguido fácil. Mas como consegui na verdade me estrepar de cara nela.. meu CRA acabou indo para 7.6 no primeiro semestre.

Agora em 2008-2 eu não tenho certeza, acho pouco provável. Porém das 7 matérias que fiz (30 créditos, um recorde no meu boletim), somente a nota de 4 entraram. Como espero passar nas outras 3 com uma nota boa também... então acho que este poderá ser o período onde meu CR (do período) voltará a subir :P (Essa coisa de ir caindo 1 décimo a cada período é muito triste)

Então assim que sair as outras 3 notas eu atualizo isso aqui.

De qualquer jeito, estou me dando um 0 aqui... pois acho que não conseguirei chegar no CRA = 8, porque dei muito mole com Física 3... mas também não deixei tudo ir pro buraco, e fui relativamente bem em tudo neste segundo semestre (nem fiz PF de Física 2 e Calculo 3 \o/).


Subtotal: -1.

3 - Ler pelo menos 1 livro técnico por mês. Mais os que eu tenho e não li por inteiro até hoje.

Essa foi mal formulada :P
Enfim... não foi perfeito, mas não foi um completo desastre.

Percebi que as vezes fica muito complicado você ler tudo que quer quando tem que dividir o tempo com livros de Calculo, Física, apostilas, etc...
Não é impossível, mas requer uma organização melhor, que não tive esse ano.


Mas os livros off-facul que li durante o ano:
Não técnicos:
- Elite da Tropa
- The Art Of Intrusion
- Field Guide to The Apocalypse, Movie Survival Skills for the End of the World
- How to Argue & Win Every Time: At Home, At Work, In Court, Everywhere, Everyday
- Where's My Jetpack?: A Guide to the Amazing Science Fiction Future that Never Arrived
- O Universo Numa Casca de Noz

Técnicos:
- Rootkits: Subverting the Windows Kernel
- Buffer Overflow Attacks: Detect, Exploit, Prevent
- Hacking Exposed: Computer Forensics


Total: 9 livros.

Não foi um espetáculo realmente... mas com muita boa vontade, posso dizer que me esforcei. Então aqui também vou me dar um 0, neutro.


Subtotal: -1.

4 - Publicar pelo menos 4 artigos/how-to/tutoriais, documentos, pelo GRIS.

Ok... esse foi triste e nem vale comentários.
Merecia até um -2... anyway...


Subtotal: -2.

5 - Fazer com que o GRIS apresente trabalhos/pesquisas próprios em pelo menos 2 eventos.

Há! Finalmente algo que eu consegui fazer!
Começou no Workshop I, teve continuidade com as apresentações na semana da Jornada de Iniciação Científica e que finalizaram com o Workshop II.

Todas as apresentações podem ser obtidas aqui:
http://www.gris.dcc.ufrj.br/apresentacoes.php

Aqui eu acho que posso me dar um +1 \o/


Subtotal: -1.

6 - Bombar no desenvolvimento do Labrador =]

Sacanagem... quando eu ja tava ficando feliz.
Outra negação... -1.


Subtotal: -2.

7 - Contribuir com pelo menos 1 destes projetos, nem que seja com patch, bug-reports, etc...: KDE, Amarok, Linux(Kernel), Gentoo/Sabayon, Fedora, Kubuntu.

Esse foi aos 35 do segundo tempo, as foi!
No início de janeiro, resolvi tomar vergonha na cara... e aceitei a um "chamado" por voluntários ao KernelTeam do Gentoo. Apesar disso, acabei me desviando bastante para o SecurityTeam :P

Pretendo continuar contribuindo com o SecurityTeam, mas voltar a ajudar o KernelTeam =]

Hoje, minha conta no Bugzilla, contem 14 bugs reportados (13 de segurança) =]

Acho que aqui... posso me dar um +1 também. Afinal, antes tarde do que nunca... e o negócio é continuar sempre para quem sabe, conseguir me tornar um Gentoo Developer!


Subtotal: -1.

8 - Participar do torneio interno de programação da UFRJ. Montar um time, participar da seletiva da UFRJ e quem sabe da etapa do RJ.

Este e o de cima foram meus maiores orgulhos :P

Meu time DCC-Drunk C Coders, junto com o Felipe (Mascote) e o Leonardo Inácio... eu realmente não esperava formar time com eles. Afinal eles tinham feito TEP e sabiam um monte de macetes/dicas... mas que foram me passando tudo durante toda esse periodo de seletiva e na maratona mesmo.

Bem, nosso time foi para a fase carioca e acabou ficando na quinta colocação.
Mesmo com 5 vagas para o RJ, infelizmente, não fomos por causa do limite de 2 times por universidade, onde a UFRJ também ficou com o terceiro e quarto lugar da fase carioca.

A fase do RJ é uma das mais fortes e disputadas, junto com a de São Paulo emho.
Times bons da PUC, UERJ e IME disputam e foi bem legal colocarmos 3 times no Top5 da fase carioca =]

De qualquer modo, é apenas mais um incentivo a este ano de 2009, para treinarmos e irmos a fase brasileira... quem sabe mundial?!

É isso... Drunk C Coders estará de volta... e com 2 garrafas de vodka e 1 de amigo zé! :P

Então... resumindo tudo, acho que posso me dar +1 aqui =]


Score final: 0.



Este foi o diff entre meus planos para 2008 e o que realmente eu fiz.
Agora esta na hora de começar a pensar nos meus objetivos para 2009. Vamos ver... e que em 2009 eu consiga um score positivo =]

GCC -Wpadded e alinhamento de dados em uma struct

Estou lendo a documentação do GCC (sim... só por esporte) sobre as opções de warning e entre umas e outras que quero testar (mas tenho que antes ler sobre as outras flags). Então agora vou falar sobre a -Wpadded.


Basicamente, ela diz ao GCC para imprimir warnings quando for necessário fazer padding para ajustar o alinhamento de alguma struct.
(Para dúvidas do que seria o alinhamento na memória: http://en.wikipedia.org/wiki/Data_structure_alignment)

Por exemplo:

typedef struct _mystruct{
        int tam;
        char bchar[2];
        double res;
        char bcode[2];
} mystruct;

Quando compilo com -Wpadded, ele avisa:
$ gcc -o struct_align.o struct_align.c -Wpadded
struct_align.c:4: warning: padding struct to align ‘res’
struct_align.c:6: warning: padding struct size to alignment boundary

Ou seja... ele teve que fazer um padding (basicamente, encher com 0 ou porcarias que não serão utilizadas) a região entre bchar[2] e res, para poder deixar res alinhado.
E novamente, teve que fazer um padding no final, para deixar a struct toda (o final dela) alinhada.

Para comprovar isto, vamos ver que através do sizeof() vamos pegar o tamanho dos dados:

Sizes:
-int      = 4
-char     = 1
-double   = 8
-mystruct = 20

Epa!
A struct era para ter 1 int, 2 vetores de 2 chars cada e 1 double.
Logo o total deveria ser 1x4 + 2x2x1 + 1x8 = 16 bytes.

Mas por que essa joça ficou ocupando 20 bytes? Exatamente por causa do padding.
Vamos criar um mapa de como a struct deveria ficar na memória, se não houvesse o padding:
(Vamos supor que nossa memória começa no 0x0000)

0x0000 - tam
0x0004 - bchar[0]
0x0005 - bchar[1]
0x0006 - res
0x000E - bcode[0]
0x000F - bcode[1]

Ou seja, num diagrama ficaria algo assim:

|----------------------------------------------------|
|   END  |  BYTE0   |  BYTE1   |  BYTE2   |  BYTE3   |
|----------------------------------------------------|
| 0x0000 |   tam    |   tam    |   tam    |   tam    |
|----------------------------------------------------|
| 0x0004 | bchar[0] | bchar[1] |   res    |   res    |
|----------------------------------------------------|
| 0x0008 |   res    |   res    |   res    |   res    |
|----------------------------------------------------|
| 0x000C |   res    |   res    | bcode[0] | bcode[1] |
|----------------------------------------------------|
| 0x0010 |  ........................................ |
|----------------------------------------------------|

Eu tentei fazer o diagrama de modo a simplificar, com cada linha contendo 4 bytes, ou seja 32 bits... o tamanho de uma palavra de dados de um processador de 32 bits (ou um de 64 operando em modo de 32 ;).

Mas como dito antes (veja o link para a wikipedia mais acima), os dados devem estar alinhados na struct, de acordo com o maior (que ocupa mais espaço) tipo de dados utilizado na struct, então o GCC insere um padding, logo ficamos assim:

0x0000 - tam
0x0004 - bchar[0]
0x0005 - bchar[1]
0x0008 - res
0x0010 - bcode[0]
0x0011 - bcode[1]

E assim no diagrama:

|----------------------------------------------------|
|   END  |  BYTE0   |  BYTE1   |  BYTE2   |  BYTE3   |
|----------------------------------------------------|
| 0x0000 |   tam    |   tam    |   tam    |   tam    |
|----------------------------------------------------|
| 0x0004 | bchar[0] | bchar[1] |   PAD    |   PAD    |
|----------------------------------------------------|
| 0x0008 |   res    |   res    |   res    |   res    |
|----------------------------------------------------|
| 0x000C |   res    |   res    |   res    |   res    |
|----------------------------------------------------|
| 0x0010 | bcode[0] | bcode[1] |   ...............   |
|----------------------------------------------------|

Até aqui temos 18 bytes utilizados (16 que queremos e 2 de padding).
Então, o GCC preenche os 2 bytes finais também (ver OBS1 no final):

|----------------------------------------------------|
|   END  |  BYTE0   |  BYTE1   |  BYTE2   |  BYTE3   |
|----------------------------------------------------|
| 0x0000 |   tam    |   tam    |   tam    |   tam    |
|----------------------------------------------------|
| 0x0004 | bchar[0] | bchar[1] |   PAD    |   PAD    |
|----------------------------------------------------|
| 0x0008 |   res    |   res    |   res    |   res    |
|----------------------------------------------------|
| 0x000C |   res    |   res    |   res    |   res    |
|----------------------------------------------------|
| 0x0010 | bcode[0] | bcode[1] |   PAD    |   PAD    |
|----------------------------------------------------|
| 0x0014 |  .......................................  |
|----------------------------------------------------|

Logo, temos uma estrutura que utiliza 20 bytes, quando realmente desejamos utilizar 16... isso é um overhead de 25%!


Para corrigir este tipo de problema é simples, vamos agrupar os dados que estão quebrando o alinhamento, ou seja, nesse caso vamos deixar os dois vetores de char juntos:

typedef struct _mystruct_fixed{
 int tam;
 double res;
 char bchar[2]; 
 char bcode[2];
} mystruct_fixed;

Poderíamos também ter movido o bcode[] para antes do res... os dois modos irão arrumar o alinhamento da struct e com isso ela passará a ocupar os 16 bytes que desejávamos. Porém eu pessoalmente acho melhor colocar todos os char[] no final, pois se desejarmos alterar o tamanho de algum deles, não teremos que nos preocupar em reorganizar tudo.



Bem... espero que tenham gostado... e pensar que escrevi isso tudo, pois só queria comentar sobre a opção -Wpadded que não é ativada pelo -Wall nem pelo -Wextra :P

Para quem quiser, estou disponibilizando um fonte (struct_align.c) aqui:
http://www.dcc.ufrj.br/~brunobuss/code/struct_align.c


Todas os testes foram feitos com a seguinte versão do GCC:
$ gcc --version
gcc (Ubuntu 4.3.2-1ubuntu11) 4.3.2





OBS1:
Naquele caso, o gcc preencheu o final da struct, pois na mesma tínhamos dados que eram alinhados em 4 bytes (ou múltiplos de 4 bytes), em um caso de uma struct do tipo:

typedef struct _mycharstruct{
 char bchar[5];
 char bcode[4];
} mycharstruct;

O GCC não irá incluir nenhum padding, pois não será necessário alinhar a estrutura. Logo esta struct irá ocupar 9 bytes como esperado.

Porem, caso tenhamos:

typedef struct _myshortcharstruct{
 short a;
 char b[1];
} myshortcharstruct;

O GCC irá fazer padding no final da struct para alinha-la com o short, ou seja... caso o tamanho de b, não seja múltiplo de 2 (short == 2 bytes), então o GCC irá colocar um byte a mais para o alinhamento.

1º Aulão GNU/Linux do GUL-UFRJ

Venho desde ontem pensando o que escrever sobre, mas depois de ler o post do Davi, não tenho nada a acrescentar ou remover do texto que ele escreveu:
http://davivercillo.blogspot.com/2008/09/1-aulo-gnulinux-do-gul-ufrj.html.

E como o safado não colocou o nome dele, vai aqui o agradecimento a ele, que como sempre é o mais empolgado, mais entusiasta =D

Lista de pessoas que tornaram isso possível:
Davi Vercillo (Robert Stallman)
Bruno Buss (Magoo)
Flávio Costa (Coutinho)
Francisco Vianna (Xico)
Jonas Arêas (Jonas?)
Marco Elisio (Marquinho)
Rafael Lopes (Bola)
Thiago Elias (Armandinho)


E claro aos professores Jonathan e Gabriel do DCC, que literalmente, salvaram o aulão. =]


Para quem ainda não conhece o GUL:
Portal:
http://www.dcc.ufrj.br/~gul/
Lista de discussão:
http://groups.google.com/group/gul-ufrj

Yeah! Top 10 baby!

Que emoção... consegui ficar no top 10 e na primeira página do ranking de um problema finalmente:
http://acmicpc-live-archive.uva.es/nuevoportal/rankprob.php?p=3964

Realmente não é nada de demais... o importante é passar... mas que é muito legal é =D

BTW, foi esse problema.

O "Mercado de Trabalho" e a falta de inovação...

Quem me conhece sabe como sou contra o foco exagerado que as faculdades dão no "Mercado de Trabalho" e como isso é prejudicial, emho.

Acho que universidades deveriam ser centros de pesquisa, desenvolvimento e inovações... e não um "cursinho de treinamento para o Mercado de Trabalho".


Infelizmente isso faz com que muitas pessoas que entrem em cursos de tecnologia como CC, acabem focados demais neste "Mercado de Trabalho". Isso é facilmente percebido pelo baixo número de patentes que o Brasil produz (não... não sou a favor de patentes que travem tudo, mas é um medidor das coisas que são desenvolvidas)... acho que o número de artigos científicos também é baixo.

Anyway... por que estou falando isso? Pois hoje calhou de achar este post nos meus feeds RSS. Recomendo a leitura.

Netuno e o Top500

Saiu a classificação do Netuno (ou aqui) no ranking Top500 (de Supercomputadores) de Junho de 2008.

Apesar de não ter ficado entre os top100 como era a ambição inicial, não deixo de achar um ótimo resultado. Vejamos um pouco da trajetória do Brasil neste ranking...

Em Junho de 2004 o Brasil chegou a ter 8 Supercomputadores nessa lista, o melhor classificado deles era o "xSeries Cluster Xeon 3.06 GHz - Gig-E" da IBM em 37° lugar.

De lá para cá, o número só foi caindo, tanto que no ultimo ranking em Novembro de 2007, o único Supercomputador do Brasil na lista era o bw10 da Petrobrás em 449° lugar.

Agora com a inclusão do Netuno e de outros, o bw10 não conta nem mais na lista top500, então o único representante brasileiro atualmente é o Netuno em 138°.

Então, emho, o Netuno não tomou um banho de água fria, mas voltou a garantir um lugar para o Brasil nessa lista =]

Só espero que esse tipo de investimento ocorra mais vezes no cenário acadêmico brasileiro para, quem sabe um dia, termos 8+ Supercomputadores novamente nessa lista =]

V Processo Seletivo GRIS

O Grupo de Resposta a Incidentes de Segurança – GRIS, grupo acadêmico do Departamento de Ciência da Computação da Universidade Federal do Rio de Janeiro vem tornar pública a abertura de seu Processo Seletivo para 2008.2. As inscrições estão abertas de 13 a 26 de Junho, sendo possível fazê-las através do link:
http://www.gris.dcc.ufrj.br/form_inscricao.php.

Conhecimentos técnicos prévios não são necessários, sendo suficiente a vontade de desenvolver-se na área de SI.

Maiores informações sobre o Processo Seletivo do GRIS:
http://www.gris.dcc.ufrj.br/ps.php

Maiores informações sobre o GRIS: http://www.gris.dcc.ufrj.br

Quickshots

GCC 4.3.1 Status Report


O GCC 4.3.1 estava agendado para 05/05 mas como ainda existem 3 bugs de Prioridade 1 (máxima), a liberação do RC1 foi adiada.
Os bugs são:
- a restricted pointers bug (36013).
- the x86 direction flag issue (36079). Há uma notícia sobre isso na ultima revista do GRIS.
- ppc64 cacoshl miscompilation (36090).

------

Lançado o OpenSolaris 2008.5

Não tenho o que dizer, apenas que foi bastante comentado... realmente não planejo testa-lo.

------

SP3 do XP finalmente saiu

Depois de sair, voltar, sair de novo... finalmente temos ele ai.

Mas nem tudo são flores no lindo campo verde do Windows XP, parece que algumas pessoas com computadores montados por empresas como HP, e que utilizam processadores AMD, estão tendo problemas de reboot infinitos pois o SP3 futucou os drivers de gerenciamento de energia e acaba misturando coisa da Intel e da AMD.

------

Deputado quer proibir novos feriados no Estado do Rio

Não levantando o mérito se quem propôs a idéia realmente trabalha ou só mama. Mas a idéia foi boa.

O Brasil não é um país de primeiro mundo caralho... e ainda queremos sair criando feriados e enforcando trocentos outros dias. Puta que pariu... e o pior é ver nego defender os feriados.

Que porra de feriado de São Jorge é aquele??? OMFG...

------

Liberado Linux 2.6.25.2, 2.6.25.3, 2.6.25.31415926

O motivo do .2 é uma falha de segurança que por causa de uma Race Condition em conjunto com algumas outras coisas pode permitir uma elevação de privilégio.

O .3 corrige além de outras coisas, 2 bugs que tem implicação com a segurança do sistema também. Também é recomendável que quem estiver usando a série 2.6.24.y atualize para a série 2.6.25.x.

GSoC 2008: Projetos que foram aceitos

Ainda não foi a vez do meu (até pq eu nao mandei a minha application :P), mas o Google liberou a lista de todas as propostas aceitas.

É uma loooonga e extensa lista, mas bem legal de se ler... pois saber o que está por vir nos seus projetos preferidos =D
http://code.google.com/soc/2008


Alguns projetos com algumas idéias *muito* legais:
- FreeBSD:
Eles estão com MUITAS coisas legais... mas as que mais me chamaram a atenção (por ser sobre segurança?) foi o "802.11 Fuzzing and Testing" e "TCP anomaly detector".

- GCC:
Entre 2 melhorias no Fortran (que eu nem penso em usar) e uma para o C++0x (padrão C++), a que mais me deixa ansioso é a "GCC Improvements on Windows" porque pessoalmente, hoje, eu acho o mingw uma merda. Não faço questão de usa-lo... mas seria bom se pudessemos usar o mesmo compilador no windows e no linux =]

- Gentoo:
Apesar de hoje não utilizar mais o Gentoo e todos os problemas que este incrível projeto vem passando, vejo 2 propostas bem legais para ele: "revdep-rebuild reimplementation" e "Automate It All". A primeira realmente deverá ajudar os usuários e a segunda deverá desafogar os devs.

- GIT:
Apesar de ainda não estar utilizando o GIT muito ativamente, estou adorando acompanhar esse projeto (e a lista de discussão), para ver todas as novidades. Tirando o plugin para o Eclipse, acho que todas as outras propostas serão de um grande benefício geral =D

- KDE:
Meu ambiente gráfico por escolha =]
Tudo que é melhorado ou adicionado nele eu gosto (bem, quase sempre :P).
O que eu achei legal foi a boa quantidade de propostas aceitas em relação ao Amarok... best player ever =D

- Nmap:
Os principais focos são o Zenmap (GUI para o Nmap) e o Nmap Scripting Engine (NSE). Também há uma proposta de refazer o netcat e o hping como ncat e nping... pois são duas partes que o projeto pode se beneficiar extensamente. As outras duas são correções de pequenos bugs em geral.

- OSVDB:
Acho que não tem muita gente que conhece esse projeto, mas foi bem legal ele ter conseguido 3 vagas no GSoC.

Como eu não posso ficar aqui o dia inteiro comentando todos os projetos que eu gosto, então recomendo que vocês deem uma olhada, mesmo que rápida, em (quase) todos, vale a pena =]

Onde estão os programadores de amanhã?

Um artigo interessante surgiu na lista do CAInfo (afinal, algo relacionado ao curso tinha que sair ali :P).

Ele fala sobre a atual preparação que os cursos (Faculdade) de Ciência da Computação estão dando a seus alunos. Ele fala sobre a falta das noções de Cálculo, programação de nível mais baixo, algoritmos, o ensino de uma linguagem de muito alto nível logo no início, etc...

Bem, concordo com o artigo. Talvez hoje as faculdades estejam preparando Tecnólogos e não Cientistas, e olha que o artigo fala da situação nos EUA. E as vezes não são encontrados profissionais qualificados (novidade?).


Então, apesar de as vezes reclamar da quantidade cálculos, físicas e outras dificuldades do curso de CC na UFRJ, tenho que admitir: ELE É FODA! =]

Por isso espero poder aproveitar tudo que ele tem a oferecer. Muitas vezes nos vemos apenas preocupados em quão fácil é uma matéria, se o professor é tranquilão, se ele passa "trabalinhos" fáceis, e se aprova todo mundo.

Pelo amor de deus, estamos em uma faculdade federal, o imposto de uma nação inteira (ou o que sobra dele) está sendo investido em um bando de malucos que no fundo ama computação. Mas quando eu digo ama, é AMA mesmo, computação como OBJETIVO e não como mera ferramenta.

Então venho propor a todos os meus colegas e até os que eu não conheço que alteremos nosso foco, não mais para qual matéria (ok, ok... Cálculo) é mais "fácil de passar", mas vamos tentar absorver todo o conhecimento que a disciplina tem a passar para você, todo o conteúdo a ser adicionado na sua "bagagem intelectual" =]
Esse será um desafio pessoal tambem, mas farei o possível para me preocupar, não em passar, mas em aprender. Creio que um seja mera consequência do outro =]