Netiquette (RFC1855) is a set of standard rules on writing electronic mail. Many of those conventions appears to be lost in time, and bad practices on writing emails are more popular around the Internet. I agree with those rules, but I think that some additional stuff can be used to get more organized electronic mail. Here are some rules, some of them extracted from the netiquette used on mailing lists and Usenet.

the subject matters

Sure, a good subject can be used to index properly your emails. For example try to use some kind of convention, do not throw the subject as a previously known conversation. For many years I’ve been using my own convention on electronic mail subjects for my projects. Generally I use the form: "Client, Project, Real Subject" or "Project, Real Subject". So you can easily find your messages related to each project just by looking on the subject. The proper subject is a good introduction to the email that you will write or read.

the format matters

Plain text (text/plain), wrapped on column 76 or 64 — it depends on your taste — with well formed paragraphs and using the proper mime encoding for localization — on Usenet and some mailing lists is useful to use US-ASCII as encoding. Many companies are using HTML formatted mail with those gif images as company logos attached, and sometimes a huge disclaimer as email footer, and many replying on top of the previous message. Well, your fancy looks ugly here. I use Kontact, hence I use Kmail and a great feature of Kmail is the fact that it do not opens HTML formatted mails immediately, it regards my preference and ask me if I want to open it. Do you remember the I love you virus which was spreading through electronic mail?. Fancy colors and pictures leave your mail looking as SPAM, overfilled with propaganda, and those huge disclaimers for me are a disrespect to me, since it is like to send a real mail, and mail service opens the envelope and attach another document into it.

A possible solution is to standardize the proper E-Mail header for those bring that information without modifying the content of the original message:

• X-Company-Logo, should contain an URL to the company logo. I hope that it should reside under HTTPS protocol.
• X-Disclaimer, should contain an URL to the company disclaimer of the electronic mail.
• X-Sender-Identity, should contain an URL to the sender contact information, possibly a vCard or a plain text signature.

Sending that information — since most SMTP email is authenticated — can be easyly inserted on the electronic mail and it will become a part of the envelope, not the original message.

labeling for indexing

Many mail clients are using labels to create additional indexes on the electronic mail, but seems that is not standardized. Here an additional mail header should be useful — I hope that most companies will agree. X-Labels should be used to add labels to the electronic mail, it can be delimited with the ;; string. So, it will become standardized for most clients, including on sending mail, so the mail client can receive them and ask the user if he wants to add the label.

conclusions

Read some mailing lists or Usenet newsgroups to get introduced on how to write and read electronic mail. Read the RFC 1855 to get the real rules on formal electronic mail. Stop sending that fancy electronic mail, it has no sense, your company will not be more respected by sending those mails, for many people it has the opposed effect.

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

One of my most recent projects is a Meta-Parser. The core requirement is to write a dynamic parser, which can be configured, allowing the user to setup certain patterns around the given input and extract those pattern tokens to being exposed to other layers of the main project. Surely this is a challenge, and interesting part of the global project. I’ve finished to work on this part of the project, it is implemented in C++ as the client requires it, and I’ve made a simple model based on the PAC architectural pattern.

overview

First we need a concrete class implementing the parser, but it needs an abstraction layer and also something which provides the proper parsing states to its internals. Finally we need to expose those extracted tokens outside of this component — the meta-parser.

Clearly the abstraction is made in top of a single template, the control is given from the ParserService class and the presentation is provided through the Token interface with the proper implementations.

substring automaton

Another interesting point is how specific string parsing is implemented. The system uses an FSM, which implements a simple automaton:

So, parsing the left hand token implies parsing the value token and then it states the right hand token, to complete the cycle reaching again the stored value token . This is used to extract substrings. Where every token is configurable with a proprietary language. Finally, the full parser specific implementation is made on top of state machines which are used according the proper configuration representation using thitd party classes and structures, so is possible to extract the required tokens from the input source.

Also, each configuration and parser instances are designed for concurrency. The project will be running on with parallel tasks inside a mutithreaded — and possibly multiprocess — service daemon. Driven by my client schedule, I can not implement wait free algorithms, so I will be using standard operating system provided locks — and more easy to handle algorithms.

in deep with abstractions

Although the PAC pattern is designed for user interfaces, the usage of this pattern to communicate components and generate strong abstraction layers helps a lot on design and maintainability issues. Indeed, this patterns guarantee a reward while we are coding some design patterns. In this case, for example the MetaParser and the ParserService are both an instance of Adapters, where a transformation is made from one layer to other. While MetaParser is a strong abstraction layer for the given implementations.

Finally ParserService provide us the proper way to handle different parsing tasks, so we can determine inside it which abstraction to use though the proper MetaParser instance.

conclusion

The PAC pattern can be used to implement component communications and proper abstraction between application layers, among the usage on user interfaces. Does it falls in other architectural pattern? Anyone knows?.

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

Hace unos días comentaba con alguien por ahí, los distintos cambios de voz que ha tenido a lo largo de los años el líder de mi banda favorita.
Iron Maiden ha venido en varias ocasiones a Chile y en las últimas, mucho pokemón con aires de maldad joven se ha podido delietar con el tema insigne para abrir conciertos, hablamos de Aces High. Creo que los años no han pasado en vano y a pesar que la voz ya no es la misma, Bruce ha podido adaptarla usando técnicas vocales diferentes, es mas, en el presente si que parece Sirena Anti Aérea .

En el pasado, la voz era bastante distinta y creo que muchos coincidirán conmigo al decir que me hubiese gustado escuchar a Maiden tal como sonaban en la gira World Slavery Tour .

Centrándome en la interpretación de Aces High y haciendo comparaciones de todas las versiones que he oido ( y que son bastantes ), me quedo lejos con la de Polonia en 1984 .

En ningún otro concierto he oido el “Ruuuunnnnnnnn….!!! ” de aces high de esta forma ( Debería haberlo conservado así ) .

Aprovechando los días libres en Santiago, hice lo que quizás hace 6 meses jamás hubiese hecho, ir a un concierto No Metal , esta vez fui a ver a “The Cranberries”… Si, lo se, algunos conocidos me dirán mamón te perdiste el concierto de metallica, pero no me interesa, tenía muy buenas razones para ir .

No soy un seguidor de este grupo, sin embargo algunas canciones las ubicaba, al final, sea como sea, se pasó excelente.

Todo muy ordenado y salvo problemas técnicos en la mitad del concierto (Se apagaron las pantallas gigantes y la amplificación)) y el final abrupto sin despedida ( Creí que saldría a despedirse pero se fueron rápido ).

En resumen, buen concierto y sonido, no conocía el recinto y no resultó un mal lugar después de todo, ya que le tenía poca fe a la acústica de un lugar tan cerrado.

I don’t use recipes to ensure the quality of my software. Most of those development tasks to make the software a reliable tool are techniques learned along the time, without considering the methodology behind the software development. I can’t stand for any methodology as the better methodology that you can use. I just follow few commandments or rules on software development, and all of them bring me good results.

1. "request well specified requirements"

   Request well specified requirements. Even if you are using one of those dynamic methodologies. Never let your boss to set ambiguous requirements, this will be your hell and nightmare, and request a formal requirement in the proper email and documentation. I do not mean a word document with tons of lines, I’m talking about requirement clarifications, where you are responsible to request the proper clarifications if you are looking something ambiguous. Also your boss is responsible to write well specified requirements, both technically and functionally. There are well known gay bosses who send ambiguous requirements and usually they are changing those requirements every day… Yeah! the same ones who are delivering your application with the initial deadline even when they are taking new ones! If the client do not have the proper knowledge about software, the client do no have the proper knowledge to evaluate deadlines, the same happens with your boss.

2. "formalize your progress"

   Formalize your work progress, by using mails, the proper VCS comments, and source code documentation, even is that is required by your boss or not. You need to register properly your work progress, and you must create the proper sub-milestones for each project milestone which is assigned to you.

3. "forget that job without a technically skilled boss"

   Do not work on company where your boss is not capable to define properly what he wants and even on a company where the boss is not capable to catch the client requirements. A boss must be capable to charge every new requirement to the client, if your boss do not do that, your boss is giving away your time and your life. If your job requires you out of workday, your job sucks, and even your boss, since he/she is not capable to handle new requirements and make the proper charge. Also, a good manager knows that you need the proper time to do all those tasks listed bellow

4. "clean code"

   Clean code, legible code and well indented code will allow more developers to handle it. If work on a company where real teamwork matters, everyone will be capable to support your development if you are busy in other task. Clean code is that one which has few ugly hacks — most of them regarding software performance — and follows well known coding standards, such as naming conventions, indentation rules and documenting techniques. Regard a 7 bit US-ASCII encoding, and never use accents — simply because some editors, compilers, and coding tools do not support other encodings and most software is compatible with 7 bit US-ASCII encoding. For localization use external packages, such as property files in Java, gettext files with C and C++, and related tools.

   You always must have in mind that your code will be taken into the most ancient platform and the most newbie coder — just someone what happens to some environments when you setup UTF-8 encoding on the project and you add a non UTF-8 file in it, and the headache that you get when you are not conscious about WTF is happening. Your boss will be entirely happy with the lost time…

5. "commented code"

   Well documented code is not that one which holds poetry inside it. Useful and descriptive comments are those ones which allows the developer to understand which logic is contained in your functions. Also you must comment every hack separately, for example if you change a b * Math.pow(2.0, a); operation by a << b to get more performance, comment it!

   There are well known commenting techniques. Take a look on known documents, such as manual pages to have wide perspective on how to comment the code — manual pages have the best documentation structure that I’ve ever seen. I think that toy documentation, like javadoc, really sucks, since it is poorly redacted and non descriptive. Do you really know someone who is able to develop an entire Java application just by looking at the javadoc without looking for examples? The same happens with C# and .NET documentation.

6. "use annotations to track your project"

   Classical annotation, on your VCS or code comments will help you to track pending tasks, enhancements that may be done and will allow you to pass messages to other developers. There are classical ones TODO: and XXX: for example. You can use TODO for all your "To Do" tasks in each file and "XXX" for precisely document hacks and enhancements that may be done on the code. This will ensure that pending tasks will never be lost in some ugly word document on an erased mail which tries to poorly describe a required task. Also you can support those tasks by using Issue Tracking and Bug Tracking systems, but are like those ugly lost documents and you can not explain in detail with the code itself which task is required where

7. "check for null pointers"

   Before using an object, check if it is null, otherwise use an error catching mechanism. This rule do not needs more explanations, and is a well known issue and spotted the right title: The Billion Dollar Mistake.

8. "do not trust user input".

   I do not trust the user input, never. I’m always trying to validate the user input, since the common user is doing mistakes using applications. The user input and generally the input in your functions require certain validation, from the data type to expected values, such as range or length. Validation in Web Applications should be made in both sides too, the Web Browser — using JavaScript and HTML attributes — and the server side. The most important one is the server side validation and it is a must. On other kind of applications, user input must be validated too.

9. "apply debugging".

   Do not stay comfortable with the code working. Debug your applications, tracing each step. Remember that you can modify variable values in your code inside your debugger, so you can do more code hardening tests. Learn about your debugger the better as you can. Read books on debugging techniques: "Debugging" and "Code Complete", for example. I’m conscious about the fact that every language and every debugger works different, but debugging techniques are always sharing common tasks and checks.

10. "apply static analysis".

    Apply static analysis to ensure that your code is clean and using better practices. Indeed, those kind of tools will help you to discover more bugs. Some of them can do code path checking and Boolean evaluation checking. If the language that you are using do not have support from static analysis tools, it really sucks. There are well known tools for doing static analysis and source code checking, and also are well known bugs discovered along the time with those tools. You must combine debugging and static analysis together.

If you do not work on a company where you do not have the proper time to do each of those tasks listed above, your job sucks. Surely you are delivering bad code, sometimes with those invisible bugs that appears when you are not expecting them. Falling one time and another on the same bugs and the same project that may not be released at time.

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

"…premature optimization is the root of all evil".
— Donald Knuth

I agree with the fact that we must do our source code level optimizations when we have finshed the construction stage or it is almost complete. I was searching articles and papers about optimizing C source code to be applied on my programs and libraries. I’ve collected some of those optimizations. But you must not confuse algorithm optimization, source code optimization and compiler optimization, since the first one refers to algorithm design and the second one just refers to the algorithm implementation, and both are sharing just few common approaches to formal reductions.

Usually the source code optimization just applies well known formal reductions. We will not treat those formalities in this article. Instead we will take a look on some examples that I’ve collected, allowing a common reasoning about how to optimize the source code. Most ideas for source code optimizations comes from η-conversions using λ equivalences, allowing for example reductions from . Also, some optimizations without an apparent η-conversion, since most is done at low level, as those which are taken by the compiler and translated to less assembler instructions, such as function inlining and parameter reduction. Most η-conversions which implies η-reductions, and are called strength reductions. But we have also the opposed side, where we are — instead of doing reductions — populating our programs with more lines of code, including repeated code, such as the loop unrolling optimization.

inline code

C supports both macros and inlining functions. Both features are reaching the same effect, when the code is compiled, all inlined instructions are placed when we call the macro or the inline function. For example, a typical approach, is a max(a, b) function or a MAX(a, b) macro.

/* the slowest expression, compiling and running */
int
max(int a, int b)
{
	if (a > b)
		return a;
	else
		return b;
}

/* normal expression with inlining */
inline int
max(int a, int b)
{
	return ((a > b) ? a : b);
}

/* the faster expression using macros */
#define MAX(a, b)			((a > b) ? a : b)

The inline and the macro definitions both are similar. The macro places every occurrence of MAX(var1, var2) expressions with the ((var1 > var2) ? var1 : var2) expression. The inline does the same, and places every occurrence of max(var1, var2) with the result of the expression ((var1 > var2) ? var1 : var2). So, the macro usage is oriented to replace entire blocks of code, instead of inline functions which are oriented to replace calls and skip the assembler call instruction and its derivates. We may look examples of the call opcode in typical system calls on operating systems, such as FreeBSD system calls.

parameter reduction

Reducing parameters implies less assembler instructions. C calling convention typically push parameters into the stack, which implies that for each parameter a push opcode call is made. For example you can group function arguments — if they are use subsequently by a group of functions — under struct forms. Think a little, each push instruction in his family takes 2 clocks, varying to 18 clocks on x86 architecture — depending on vendor and model. For 8 arguments, it will take from 16 to 36 clocks, against 2 to 18 clocks with one argument. This approach on argument reduction may be applied to those functions which are not inlined.

/* slower version */
int
my_function(int arg1, int arg2, int arg3, int arg4)
{
	/* do something... */
}

/* faster version */
struct myargs
{
	int arg1; int arg2; int arg3; int arg4;
};

int
my_function(struct myargs *args)
{
	/* do something... */
}

practical reductions

We do reduction when we remove unnecessary steps in our functions. We can do most reductions just by thinking a little on the code, and also there are some well known reductions which can be used as optimizations.

removing else

/* with else, smaller code, but slower one */
inline int
test(int a)
{
	return a > 0 ? 1 : 0;
}

/* without else, large code but faster one */
inline int
test(int a)
{
	if (a > 0)
		return 1;
	/* implied else */
	return 0;
}

On this optimization, we are removing jmp and jxx family of instructions, where most of them takes near to 7 clocks on x86 architecture and also the required instruction to setup the proper context for the following instruction in the program sequence. This is like the spartan programming style, where most code is minimized through reductions and similar programming tasks.

bitwise operations

Bitwise operations are cheaper than other operations. For example, curiously, a shift operation and plus operations have less clocks than multiplication and division operations. The happens to logical evaluations. In other post, I’ve wrote about logical minimizations. A complement to what I’ve said, is the fact that mul instruction takes from 10 to 40 clocks and div instruction takes from 15 to 40 clocks on x86 architecture, against add, sub, shr, shl and similar instruction that are taking from 2 to 7 clocks. Remember that the number clocks used by some instruction is vendor and model dependent. For example if we do:

/* we take a call to the math.h function pow() */
n = y * pow(2.0, x);

/* we can replace it by */
n = y << x;

In other words, the x << y operation is equivalent to . You can find other math equivalences too. From this basic approach, we can reach other types of optimizations through the proper maths. You can take a look on the bit wizardry page from Jörg Arndt if you want to seek for more bitwise operations and reductions.

reversing counter loops

Usually we do one step loops for fixed set of counters. The following example shows a reduction which can be used every time we can do a reverse loop.

/* for loop coded usually */
for (c = 0; c < MAX_C_VALUE; c++) {
	/* do something... */
}

/* for reversed loop */
for (c = MAX_C_VALUE; c--; /* we do not do nothing here */ ) {
	/* do something... */
}

table lookups

A table lookup is the technique where we create an array and kind related structures to lookup for data, usually previously calculated data or simply, we are looking for concrete data that we want to use.

/* we can have a switch statement */
ourtype_t *varn = NULL;
switch (var1) {
case 0:
	varn = value1; break;
case 1:
	varn = value2; break;
case 2:
	varn = value3; break;
default:
	varn = value1;
}

/* or have an if/else statement */
if (var1 == 0)
	varn = value1;
else if (var1 == 1)
	varn = value2;
else if (var2 == 2)
	varn = value3;
else
	varn = value1;

/* so we can simply replace those values using arrays */
ourtype_t mapsvalues[] = { value1, value2, value3 };
varn = mapsvalues[var1];

Also we usually can setup reductions by creating table lookups and state machines, so we can create the proper map between certain variable data and certain function. State machines are a powerful abstraction which allows us to code different states inside data structures.

We can have predefined values in our table lookup tasks. Then we are using lazy evaluation. Every time we have a constant value which is requested and not calculated each time we work with it, we are doing lazy evaluation.

register keyword

/* using the register keyword should help creating faster code */
register int counter;

reduce data access computation

If we have deep constructed data structures (struct in C), every time we access most deep nodes, we are using pointer arithmetics, which implies basic math operations to access certain parts of our structures. Here we can do tow tasks: alias creation and usage and padding adjustment. Alias usage, means that we must use an internal pointer to access directly a structure member, so we omit pointer calculation each time we access it. Padding adjustment, is just about to create the proper data structure member order.

/* structure without the proper padding */
struct my_struct {
	char *a;
	void *b;
	int c;
	double n;
	char *x;
};

/* the same structure with the proper padding */
struct my_struct {
	double n;
	int c;
	char *a;
	char *x;
	void *b;
};

Also the data access computation is reduced on assembler level code, not the C code. Here we have an implied η-reduction and invisible one. For deeply and nested data structures, we have the same issue. We should have as rule that the structure size must have an ideal size of , with as the structure size and as the padding adjustemnt to power of two.

/* some structs with nested members */
struct a {
	int m1;
};

struct b {
	int m2;
	struct a *m3;
}

struct c {
	int m4;
	struct b *m5;
}

/* the non cheaper version to access its members */
struct c *x = some_function_returning_c();
x->m5->m3->m1 = some_other_function();
if (x->m5->m3->m1 != 0) {
	another_function(x->m5->m3->m1);
}

/* the cheaper version to access its members
   using aliases */
struct c *x = some_function_returning_c();
struct b *p;
b = x->m5->m3;
b->m1 = some_other_function();
if (b->m1 != 0) {
	another_function(b->m1);
}

loop unrolling

Each step on a loop repeats some instructions. For example if we have a fixed size array, where we must treat each element with certain function, we can use unrolled loops.

/* normal iteration over fixed size array */
for (i = 0; i < 100; i++) {
	call_some_function(my_array[i]);
}

/* applied loop unrolling and reverse loop */
for (i = 100; i--;) {
	call_some_function(my_array[i]);
	call_some_function(my_array[--i]);
	call_some_function(my_array[--i]);
	call_some_function(my_array[--i]);
	call_some_function(my_array[--i]);
}

Note that here we have a fixed size array. In other case is hard to know the array size. Also we can use our compiler optimization to unroll each loop, if our compiler has the proper option. For example GCC supports automatic loop unrolling by using the -funroll-loops flag.

loop jamming

Reusing blocks of code inside loops matters.

/* here we have two loops for something that can
   be done one loop */
for (i = 0; i < 100; i++) {
	some_function_a(my_array[i]);
}
for (i = 0; i < 100; i += 10) {
	some_function_b(my_array[i]);
}

/* here we have two loops for something that can
   be done one loop */
for (i = 0; i < 100; i++) {
	some_function_a(my_array[i]);
	if ((i % 10) == 0) {
		some_function_b(my_array[i]);
	}
}

On the example above we have the proper loop doing the same tasks with less operations, so we have reduced the steps of that loop from to — note that is just symbolic and not strict.

bit padding matters

It depends on the architecture. Processing data types shorter or larger than the register size do not have a cheaper cost than using them. For example if we use char or short, we are not using a complete register, which is more hard to handle than register length variables, such as int and long.

references

• Michael E. Lee, "Optimization of Computer Programs in C", Ontek Corporation.
• Adrian Barnetts, "C optimisation tutorial".
• Paul Hsieh, "Programming Optimization".
• Koushik Ghosh, Writing Efficient C and C Code Optimization, The Code Project.
• Optimizing C and C++ Code. EventHelix.
• Cris H. Pappas and William H. Murray, "386 Microprocessor Handbook", McGraw Hill.

Copyright © 2009 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2009. | Permalink | One comment
Post tags:

Hola, vengo a escribir el penúltimo articulo del glob del año.

En la parte del año que fue como las wifas (Como lo pronostique a fines del 2008) le lleva:

• Me despidieron, el único consuelo es que no fue mi culpa (La empresa murio en mala).
• Aún me estan alargando el pago de unas lucas (CTMS, mueranse)
• Par de temas personales que no vale la pena mencionar.
• Ah, y no pude regalarme nada fancy para navidad (Vease el fail del pago de lucas de más arriba)

Ahora, lo que si me salvo el año :

• Trabaje en lo que me gusta por 8 meses.
• Aprendí cosas re-entretenidas en la pega.
• Me lleve genial con un par de clientes (Gabriela y Jordana, tambien Felipe). Lastima que con otros no tanto …
• Conocí gente genial (Team DM, la gabi, el milton, la veny, el vicho, hasta javier; Ex-DM: el cesar ; y el equipo de egipcios, que lo nombro más abajo).
• Me llevo mejor con gente que antes consideraba solo conocidos
• Trabajé con un dream team para las jornadas (Al hilo tenemos a Rod, Boris, Pancho, lecaros, camila, javier y la revelación del año … pottersys xD)
• Mención honrosa para el Mozcamp y la gente de Mozilla (Sarah, you rocks)

Disculpen lo latero, la pesima redacción (Queda en el TODO de 2010) y los daños que les haya provocado el post y antes de olvidarlo: Feliz año!

As you have seen in my last post, I’ve been working on some strong changes on pyxser. Today I’ve released pyxser-1.4r and the announcement message:

Hello Python Community.

I'm pleased to announce pyxser-1.4, a python extension which
contains functions to serialize and deserialize Python Objects
into XML. It is a model based serializer. Here is the ChangeLog
entry for this release:

---8<---
1.4r (2009.12.26):

        Daniel Molina Wegener 
        * pyxser_typem.c: Added type map serialization and deserialization
        routines and arguments. Now pyxser is able to serialize and
        deserialize objects using custom serialization functions, but
        preserving the pyxser XML schema and the serialization model.
---8<---

The project is hosted at:

http://sourceforge.net/projects/pyxser/

The web page for the project is located at:

http://coder.cl/products/pyxser/

PyPi entry is:

http://pypi.python.org/pypi?name=pyxser&version=1.4r&:action=display

For a sample article on how to integrate
pyxser with ZSI WebServices:

http://coder.cl/2009/10/18/pyxser-and-zsi-webservices/

Thanks and best regards,
--
| Daniel Molina  |
| IT Consulting & Software Development    |
| http://coder.cl/                        |

I hope that this Python Extension will help you in your development tasks. For any kind of feedback, follow the pyxser announcement thread on comp.lang.python or the Python mailing lists. Another options is simply to create a thread on SourceForge forums or write an email directly to ‘Daniel Molina Wegener’ <dmw@coder.cl>

Copyright © 2009 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2009. | Permalink | No comment
Post tags:

… tejo de rayuela

Primero que nada, gracias a Cesar por la idea de usar git para backups  de ahi me vino toda esa git mania

Cuando se trata de sistemas de control de versiones, los primeros que se me vienen a la mente son git y subversion, por motivos de laziness prefiero el primero, por que lo conozco mejor y por que puedo hacer este setup con los ojos vendados (Not really )

Bueno, me ahorrare unas lineas diciendo que este setup:

• Usa llaves ssh para la autenticacion de usuarios
• Usa un repositorio git para manejar los repositorios de git (Got it?)
• Solo usa una cuenta de usuario para el manejo de git

Usaremos el proyecto Gitosis, desarrollado por Tommi Virtanen, como se imaginan el proyecto esta hosteado en git

Nos fuimos:

Paso 1: Instalar Gitosis

Instalamos git y setuptools de python:

apt-get install git-core python-setuptools

Ahora clonamos el codigo fuente de gitosis y lo instalamos:

cd /usr/src/
git clone git://eagain.net/gitosis.git
cd gitosis
python setup.py install

Paso 2: Crear el usuario para git

Creamos el usuario git (puede llamarse como ustedes quieran):

adduser \
    --system \
    --shell /bin/bash \
    --gecos 'Control de Versiones Git' \
    --group \
    --disabled-password \
    --home /home/git \
    git

Notar que tiene la contraseña deshabilitada, ya que no es necesaria; y tambien que le dimos una shell valida (Que si es necesaria para que ande gitosis).

Ahora para iniciar la instancia de gitosis, necesitaremos una llave pública RSA, si no tienen una pueden crearla con este comando:

ssh-keygen -t rsa -C janitux

Con nuestra llave lista, la copiamos al server que tendra gitosis, e iniciamos finalmente la creacion de la instancia gitosis:

su -c "/usr/bin/gitosis-init < /tmp/id_rsa.pub" git

Y este comando por si tenemos un bug en python-setuptools:

chmod 755 /home/git/repositories/gitosis-admin.git/hooks/post-update

Y comienza la fiesta, clonamos el repositorio de administracion de gitosis:

git clone git@SERVER:gitosis-admin.git

Y ya estamos listos para administrar nuestros repositorios con gitosis!

Paso 3: Crear Repositorios con gitosis

La administración de gitosis es muy sencilla, basta modificar el fichero gitosis.conf del directorio que clonamos en el paso anterior.
La sintaxis de este fichero se basa en directivas de grupos, se define el grupo, en que repositorios tendrán permisos de escritura o lectura; para más información sobre gitosis.conf ver el fichero example.conf

En fin, en este ejemplo crearemos el grupo ?equipo?, con ?pato? y ?pedro? como miembros del grupo y este grupo tendrá permisos de escritura en los repositorios ?mirepo? y ?repob?. (Nota: el nombre de usuario se determina mediante los ficheros en el directorio keydir, es el nombre del fichero, sin la extensión .pub)

[group equipo]
writable = mirepo repob
members = pato pedro

Tambien tenemos que agregar las llaves publicas de pato y pedro:

cp id_rsa_pato.pub gitosis-admin/keydir/pato.pub
cp id_rsa_pedro.pub gitosis-admin/keydir/pedro.pub

Con esto estariamos listos para dar un commit y que se apliquen los cambios:

git add gitosis.conf keydir/
git commit -a -m "Creado grupo equipo, con pato y pedro como miembros, y permiso de escritura en los proyectos mirepo y repob"
git push

Y finally creamos el repositorio con el commit inicial:

mkdir -p ~/Git/mirepo
cd ~/Git/mirepo
git init
git remote add origin git@SERVER:mirepo.git
## Hacer trabajos, agregas ficheros con git add, y haces un commit con git commit -a
git push origin master:refs/heads/master

FINALLY! estamos listos para seguir trabajando con nuestros repositorios git

Mi única recomendación, sean claros con los nombres de sus mensajes en el commit.

Y obviamente, los creditos van a Garry Dolley, por este howto

“… Pero el recuerdo aun permanece….
Todos los años pasados no son tan extraños…

….Y el invierno no es el único sueño a nuestro alrededor…

…Sé lo que quiero, digo lo que quiero y nadie puede quitarme eso…”

Cuando se trabaja con equipos que prestan servicios, el valor de UPTIME es algo fundamental, el que nuestras máquinas dejen de responder no le hace ninguna gracia a los clientes que confían en nuestros servidores. El valor de UPTIME normalmente se mide en porcentaje, siendo lo ideal mantener el 100%, aunque siendo realistas, eso nunca se va a dar, ya que tarde o temprano aparecerá alguna actualización o parche de seguridad que obligará a reiniciar los servidores.

Pingdom es un servicio de monitoreo que está constantemente verificando la disponibilidad de los servicios y lleva una estadística que puedes hacer publica para tus clientes. En cierta forma PINGDOM pasa a ser una especie de notario que certifica que tus servicios están normalmente funcionando.

El servicio es gratuito para un servidor, sin embargo para mas de uno hay que pagar.

Para mantener una buena política de seguridad en equipos críticos es importante verificar y auto explotar nuestros servicios además de contar con un equipo libre de rootkits, para ello, una buena herramienta es rkhunter, quien verifica varios aspectos de seguridad de la máquina a demas de posibles adulteraciones de binarios críticos del sistema.

Rkhunter cuenta con una base de datos de rootkits y además verifica mediante el uso de un checksum cualquier cambio en archivos ejecutables importantes del sistema.

¿Como usarlo?

Una vez instalado, bastará con ejecutar el comando rkhunter -c para que este revise uno a uno los binarios y posibles fallas de seguridad. Una vez terminado, la aplicación entrega un resumen y ademas arma una base de datos interna para el manejo de los checksum, por lo que es importante que cada vez que se deba actualizar el sistema, se haga el siguiente proceso:

Rkhunter posee un archivo de configuracion dentro del directorio de sistema etc, donde se pueden configurar opciones de envio de alertas usando correo electrónico y lo mas importante, listas blancas de archivos y directorios ocultos que aveces causan falsos positivos y no siempre son un problema real de seguridad.

Hola, vengo a contarles una pequeña historia, incluye a un cliente puteandome por no poder enviar correos en outlook via GTD y  el antispam avenger.

La historia comienza cuando me dicen que el cliente XX tiene un problema con el correo, entonces reviso los logs del server y no veo nada extraño, enviaba correos, recibia correos, todo bien! (Revise bien al pedo, por que estaba un poco ocupado en las jornadas)
Lo que siguio, es que al volver a la vida (Aproximadamente el martes o miercoles, despues de las jornadas), me llama el cliente XX a la oficina, diciendome que ha estado como dos semanas con el problema, que desde su “coso” movil movistar podia enviar correos bien, pero que desde el enlace de <no puedo decir donde estaba> no podia enviar correos. En fin, luego de 5 minutos de tratarme como idiota, me harte y pedi hablar con el encargado del enlace (Mucho más razonable, y realmente entendía lo que yo hablaba ). Despues de hacer un par de pruebas, me fije que los logs decian XXXX hostname, en las sesiones de envio SMTP, y claro, ahí saltaba avenger alegando que tenía que hacer primero un EHLO o sino era spam. Hasta ahí no entendia nada, por que diablos desde una conexión si se enviaban bien los comandos SMTP, y no desde otra; tras googlear un rato, encontre al culpable!

Según vi, los firewalls cisco tienen una función llamada “fixup protocol”, que solo permite que pasen ciertos comandos SMTP, despues de deshabilitarlo, todo volvio a la normalidad

Hoy en las noticias de Debian han anunciado que va a estar disponible un port del kernel de BSD, Squeeze será la primera rama en incluir el nuevo port.

The Debian Release Team is pleased to announce that it sees the port of the Debian system to the FreeBSD kernel fit to be handeld equal with the other release ports. The upcoming release codenamed ‘Squeeze’ is planned to be the first Debian distribution to be released with Linux and FreeBSD kernels.

Link’s

http://www.debian.org
Debian pushes development of kFreeBSD port.

El Grupo Local de GNOME – GNOME Chile – tiene el agrado de invitar a todos los entusiastas, usuarios y desarrolladores del proyecto GNOME a presentar sus trabajos dentro de la realización del evento del Día GNOME.

El Día GNOME es el evento de difusión del proyecto GNOME, más grande que se organiza a nivel nacional, y desde el año 2006 que se está realizando en diversas ciudades del país, con el objetivo de promover el uso y desarrollo de este ambiente y sus tecnologías.

Esta nueva edición del día GNOME, se desarrollará dentro del Décimo Encuentro Linux y se realizará el día Sábado 24 de Octubre en la Universidad Técnica Federico Santa María, Valparaíso, Chile

Pueden ver mas información en la Lista de Correos de Gnome Chile.

Este Sábado 26 de Septiembre se realizará en varias ciudades de chile, el Día del Software Libre.

“El Día de la Libertad del Software es un esfuerzo global de educar al público acerca de la importancia de la Libertad del Software y las virtudes y disponibilidad del Software Libre (Free Software). Los equipos locales de todo el mundo organizan eventos cada tercer sábado de septiembre. El último evento involucró más de 200 equipos de todo el mundo. En nuestro país se realizará el 26 de septiembre, debido a la cercanía de las fiestas patrias.”…

Para esta ocasión DebianChile.cl se hará presente en la sede de Curicó con un Stand, en donde tendremos algunas sorpresas para los asistentes.

Link’s

http://www.diadelsoftwarelibre.cl

UPDATE

pueden ver algunas imágenes del evento aquí

Hace algunos días por alguna extraña alineación planetaria, tuve problemas usando kopete, por lo cual… debí recurrir a la otra opción más a mano, pero del lado oscuro: pidgin. Pero gracias a...

[...]

En los próximos meses, se vienen importantes eventos en torno al Software Libre. Día del Software libre Es el más próximo. Se realizará en diversos puntos del planeta, el día 19 de septiembre de...

[...]

El Encuentro Linux es un congreso de carácter internacional que convoca a los profesionales e interesados en el sistema operativo Linux, BSD, código abierto y tecnologías afines. Es la máxima instancia en Chile sobre estos temas, y reúne a profesionales, académicos, estudiantes y empresarios para compartir en charlas, tutoriales, debates y otras actividades.

La presencia y el uso de software basado en código abierto es cada vez mayor, hoy está presente en áreas donde antes no era de uso común. Hoy en día se puede encontrar Linux en una diversa gama de dispositivos: Desde celulares y netbooks, hasta enormes redes sociales que se construyen sobre servidores basados en software código abierto.

Este año se celebra la décima versión del evento, el cual nació como una instancia para reunir a todos los entusiastas de este sistema operativo y del código abierto. Además, permite acercar y difundir el uso de Linux y el código abierto a la comunidad en general.

Invitación

Invitamos desde ya a preparar su trabajo y enviarlo a más tardar el día viernes 03 de julio. Se aceptará el envío de trabajos destinados a charlas o tutoriales (bajo las mismas condiciones). Los trabajos enviados deberán respetar la estructura y limitaciones indicadas en este documento. El envío de los trabajos será vía web, sistema que se habilitará el día 18 de mayo.

El formato de las charlas será de 50 minutos más 10 minutos adicionales destinados a preguntas.

Estructura de la propuesta

1. Título

2. Autor(es), uno de los cuales debe ser el expositor del trabajo.

3. Abstract (Resumen): Breve resumen, de no más de 5 líneas, indicando la principal idea de la charla o tutorial.

4. Keywords (palabras clave)

5. Introducción

6. Motivación: Explicación de porqué su trabajo es de interés para el público objetivo de este congreso.

7. Desarrollo del Tema

8. Referencias

9. Área en la que se centra el trabajo (ver sección ?Áreas Temáticas?)

10. Nivel (Elegir uno de básico, medio o avanzado).

11. Indicar máximo 5 puntos en los que se enfocará la presentación (no el trabajo).

12. Foto del expositor (tamaño pasaporte), una breve reseña biográfica de los autores, y la URL de la página personal o blog (si corresponde)

Condiciones

Los documentos enviados se publicarán en la página permanente del Encuentro. Deben cumplir las siguientes condiciones:

* 3 páginas, sin portada.

* Enviar en formato PDF, independiente del formato de origen.

* Se sugiere utilizar algunos de los templates que se publicarán en nuestra página web (ODF, Latex2e).

* Imágenes u otros materiales anexos sólo como apéndice extraordinario, en un máximo de dos páginas.

* Por cada trabajo se pagará el viaje y la estadía completos para un expositor (si fueran varios autores).

* Es necesario que el expositor se encuentre presente y participe de las actividades del evento.

* El material de apoyo del expositor (típicamente diapositivas) deberá entregarse el 20 de octubre.

Áreas Temáticas

El Décimo Encuentro Linux tiene como eje transversal al sistema operativo Linux y tecnologías de código abierto. También son aceptados temas que compartan estas filosofías, como por ejemplo composiciones artísticas bajo licencia Creative Commons, sistemas operativos de la línea BSD, entre otros. Algunos temas afines son:

* Administración de Sistemas

* Aplicaciones para Celulares

* Cloud Computing

* Desarrollo de Software

* Diseño Multimedia

* Educación y E-Learning

* E-Business

* E-Government

* Computación de Alto Desempeño (Grid, Cluster, Multicore)

* Licenciamiento bajo Copyleft y Creative Commons

* Netbooks

* Open Hardware

* Redes Computacionales

* Redes Sociales y Web 2.0

* Sistemas Operativos Abiertos (Linux, BSD, y otros)

* Videojuegos

Comité de Programa

* Presidente del Comité: Horst H. von Brand, UTFSM.

* Delia Ibacache, UPLA.

* Patricia Trejo, UV.

* Miguel Ruiz, PUCV.

* Samuel Pizarro, DuocUC.

* Arturo A. Hoffstadt, UTFSM.

* Sven von Brand, UTFSM.

Fechas Importantes

La hora límite de todas las fechas, son las 18:00 horas (CLT).

* Apertura del sistema web para envío de trabajos: 18 de mayo.

* Fecha límite de entrega: viernes 03 de julio.

* Publicación de resultados: 07 de agosto.

* Confirmación de asistencia: 14 de agosto.

* Envío de diapositivas o material de presentación y versión definitiva del resumen: 20 de octubre.

* Décimo Encuentro Linux: 22 a 24 de octubre.

Organizan

El Décimo Encuentro Linux es organizado por las siguientes instituciones de educación superior:

* Universidad Técnica Federico Santa María

* Pontificia Universidad Católica de Valparaíso

* Universidad de Valparaíso

* Universidad de Playa Ancha

* DuocUC

Contacto

* Sitio web: http://www.encuentrolinux.cl

* Correo electrónico: encuentro@inf.utfsm.cl

* Teléfono: +56 32 2654367.

llamado a envio de trabajos (pdf)

llamado a envio de trabajos (txt)

Es extraño haber dejado de escribir en este blog. Y no es que no tenga nada que decir(me)*, forzosamente debí bajarle prioridad a esto. Lo bueno es que ya hace varias semanas estoy...

[...]

Con la finalidad de dar a conocer los beneficios que se tiene con el software libre en lo que es área computacional, es que se desarrollará un evento en la comuna de Quintero. El tema se llamará ?Día Cultural del Software Libre? dado que se necesita culturizar a todas las personas de la comuna y alrededores, en lo que se refiere a software libre. Se darán a conocer distintos temas relacionados con la materia, en el cual vendrán expositores de fuera de la comuna, a participar de este grandioso evento tecnológico.

Personas jóvenes capacitadas, nos brindarán diversos tipos de charlas, aclarando todas las dudas de los asistentes que se encuentren presente.

El evento es totalmente gratuito. Se pide que en lo posible, participen durante toda la jornada, ya que habrán excelentes temas, y muchas cosas más.

Cabe señalar, que es primera vez que se realizará un evento de estas características en la comuna, dado que este grupo de miembros que difunden el software libre, lo hacen de forma voluntaria, y en toda la región.

Datos del Evento

Fecha: Sábado 20 de Junio del 2009

Hora: De 11:00 hrs., hasta las 18:00 hrs

Lugar: Aula Magna del Edificio DAEM de Quintero

Auspicia: I. Municipalidad de Quintero

Organiza: CostaLinux y ValpoLinux

PROGRAMA

El programa para el día del evento, es el que se presenta a continuación:

Todo cambia.He vuelto a la normalidad.Si importara...

Los laboratorios de Sistema del Area de Computacion se reubicaron en la ex sala Cisco de Zocalo.

Desde el Miercoles, ya se encuentran operativos tanto para clases o el uso general de los alumnos.

Buscando algo sin relación alguna, llegue a encontrar esto: http://factorkippel.com/citas-a-ciegas-para-programadores/ Si se sienten identificados, es mera coincidencia.

[...]

:DEso. Ando feliz.

[vimeo]http://vimeo.com/3621247[/vimeo] Si quiero ser profesional, debo pasar este semestre. Pero sin fotocopias sería imposible.

[...]

Hace unos días tuve un pequeño drama, tenía instalado amsn en una partición con Ubuntu, y necesitaba instalarlo en otro Ubuntu; el problema es que había perdido el deb, y era un build svn de amsn con otros chiches (Ergo, no me daría la paja de bajar el código del svn, buscar plugins extras ni mucho menos instalar las librerías necesarias para compilarlo).

Aquí es cuando llega dpkg-repack a salvarme, hace exactamente lo que necesitaba.
La instalación es muy simple, lo instalan vía apt y luego lo corren como root, el único argumento que necesitan es el nombre del paquete.

Ejemplo: sudo dpkg-repack amsn

PD: Les conte que ahora estoy usando KDE 4.2?

Now Playing: Pork & Beans – Weezer

Test de inteligencia emocional fail. 1. Consciencia de si mismo = 76% 2. Expresión Emocional = 47% 3. Grado de Autonomia = 62% 4. Confianza en si mismo = 81% 5. Actitud frente a los demás = 30% 6. Capacidad para escuchar = 54% 7. Aptitud para desenvolverse en grupo = 0% 8. Promedio General = 50% No me cuadra.

Me parece que se llama caburgua bajo. Si ven el exif veran las coordenadas gps

Esperando

Para los alumnos interesados en hacer su practica Profesional, la empresa Emelari esta solicitando un alumno en practica que apoye las funciones del área de informática de su empresa.

Dicha practica durará 3 meses y se cancelara $100.00 por cada mes.

Alumnos interesados comunicarse con la Secretaria del Área de Computación e Informática.

cayó tanta gente con el post de broma del dia de los inocentes en el blog del Open?, muy creible? xD
y hablando en serio, no tenia idea que la gente de la seccion open source de microsoft daba charlas!

El viernes pasado, se realizó en nuestra dependencias del Área de Computación e Informática, la llamada OSUM Pizza Party, esta actividad fue gestionada por GDSOL ( Grupo de Difusión del Software Libre ) en la cual se tenían que juntar 100 personas en la plataforma OSUM. ( La meta se cumplió en 3 días )

Aparte de la Pizza Party, se realizó una Charla de información respecto a lo que la empresa SUN, ofrece para los universitarios, desde cursos a certificaciones tanto para el alumnado como académicos.

Parte del Grupo que participo en OSUM Pizza Party

Ricardo Spencer Veas

• “Desarrollo de una Plataforma Web para solucionar la gestión de peticiones de servicios entre las unidades de la Universidad de Tarapacá”
• P. Guía : Oscar Sagardia O.
• P. Inf.:    Héctor Ossandón D.
• Lugar: 04/12/08, A LAS 15:00 HRS. SALA CENTENARIO.

Diamkel Orellana Madariaga

• “Definición de un proceso de desarrollo para sitios web basados en el CMS Joomla”
• P. Guía: Ricardo Valdivia P.
• P. Inf.:   Héctor Ossandón D.
• Lugar: 17/12/08, A LAS 8:30 HRS, SALA CENTENARIO

Hoy se recibió el siguiente correo:
==============================
Se solicita a todos los usuarios de la red informática de la Universidad
de Tarapacá tomar la debida atención a la situación que se indica a
continuación:

Gusano ataca a computadores de todo el mundo

Desde ayer 27 de noviembre a partir de las 15:30 horas se detecta un
gusano informático conocido como “conficker” o “downadup”, está atacando
a los computadores de millones de usuarios. Las consecuencias de su
ataque es el colapso en la conexión a internet de los usuarios que se
contagian al acceder a Internet.

Se sugiere la inmediata instalación de un parche disponible por
Microsoft (aquellos equipos con licencia legal).

Como prevenirlo.

1.-  Actualizar el parche de seguridad que se encuentra informado en el
Boletín de Microsoft :
http://www.microsoft.com/spain/technet/security/bulletin/ms08-067.mspx
sólo vale en equipos con copia legal del windows.

2.-  Actualice su antivirus y completa la seguridad de tu computador con
un firewall o sea activar cortafuegos local en el computador personal

3.-  Apague o desconecte su computador de la red por el momento.

Ante cualquier situación contactar a dtisopor@uta.cl o al fono 205976, o
al técnico de soporte informático de su facultad o unidad.

SOLUCION:

—–BEGIN PGP SIGNED MESSAGE—–
Hash: SHA1

Hola:

A nivel central se han aplicado reglas de bloqueo ICMP (ping a cualquier
lado) y bloqueo de los servicio Microsoft para compartir archivo e
impresoras entre InterRedes. El malware se distribuye por el puerto 445.

Mantenerse alerta a cualquier evento.

Aplicar parche sugeridos, verificar que los firewall en lo clientes
estén activos, borrar todas excepciones en el cortafuegos local y
comenzar de nuevo a dar los permisos o excepciones.

Encender o conectar los equipos debido a la situación controlada

A

A

A

A

A

Que frustrante, intento jugar al Loto en linea y no puedo.
Resulta que me inscribí el año pasado para jugar una vez y desde aquel entonces no he vuelto a entrar a dicha página…
… Hasta ahora, que intenté jugar Loto y no pude debido a:

• Intento ingresar con mis datos (los cuales tenia guardados en un correo la vez que me registré) y la pagina me indica: Usuario inválido
• Intento volver a registrarme y la pagina me indica: RUT en uso
• Intento la opción “¿Olvidaste tu contraseña?” y la página me indica: Ha ocurrido un problema al ingresar su clave
• Intento pinchar en el link “Contactenos” para pedir ayuda por mi registro y recibo un lindo Error 404

<ironic>Es increíble lo bien que funciona la pagina de polla…<ironic>
Siempre este tipo de paginas y sistemas online están hechos por webmasters/programadores/analistas/ingenieros mediocres y nunca funcionan como deberían

Ya, me descargué…

 yay!!
comienzo a bajarlo para tener mis propias conclusiones

Mas info aquí

Lastima que navidad ya paso…

schop.codemonkey.cl now open!!

Y me aburrí de movable type, así que instalé una copia de wordpress para hostear mi blog
So no mas…