Dec 10, 2007

Activation in depth

In this post I'll discuss a key concept of db4o and how it improved in our latest versions: object activation. I'll focus mainly on the .Net version but these concepts apply equally well to the Java version.

In order to access some resources listed in this post you will be required to register (for free) in

Activation in depth

Activation in db4o parlance is the process of loading object data from the database to memory. You can see this concept in practice by asking db4o to not activate objects at all and having a look at them. Objects that are not activated will have only its object identity loaded from the database (In order to see the identifier for an object stored in db4o you can


After building the graph of candidates (objects that satisfies a query's conditions), db4o needs to know how deep in this graph it must go activating (i.e, reading the object's data into memory). At this point it may seems that we have two contradictory objectives: i) we want to make db4o as transparent as possible to developers (making it easier to be used); ii) we do want to make sure that db4o will use computational resources (in this case memory) as efficiently as possible.

The simple approach to achieve i is to activate the whole graph but this clearly contrasts to ii because it may exhaust all free memory if the query returned a lot of objects. By the other hand, the easiest way to achieve ii (from the perspective of memory utilization) is to read only the identity of the objects in the graph and
leave to the developer the responsibility to activate them when needed. Again, this strategy goes against the other one (i.e, simplicity of use). db4o latest versions includes a new functionality (conceptually called Transparent Activation, or simple TA for brevity) aimed to achieve both goals (i and ii) without sacrificing each other.

Consider the following classes:

public class Person : SupportObjectId
    private Address address;

    public Address Address
        get { return address; }
        set { address = value; }

    private string name;

    public string Name
        get { return name; }
        set { name = value; }

   private int age;

   public int Age
      get { return age; }
     set { age = value; }

   private Person parent;

   public Person Parent
       get { return parent; }
       set { parent = value; }

   public Person(string name, int age, Address address, Person parent)
   { = name;
        this.address = address;
        this.age = age;
        this.parent = parent;

   public override string ToString()
       return PrintInfo(0);

   private string PrintInfo(int i)
       string tab = new string('\t', i);
      return string.Format("{0} {4} {1}{5}\r\n{4}{4}Address: {2}\r\n{4}{4}Parent: {3}",
                                        (name ?? "null"),
                                        (address != null ? address.ToString() : "null"),
                                        (parent != null ? parent.PrintInfo(i+1) : "null"),

public class Address : SupportObjectId
    private string street;
    public string Street
         get { return street; }
         set { street = value; }

    private int number;
    public int Number
        get { return number; }
        set { number = value; }

    private string city;
    public string City
        get { return city; }
        set { city = value; }

    public Address(string city, string street, int number)
   { = city;
        this.street = street;
       this.number = number;

   public override string ToString()
        return "[" + (street ?? "**") + "(" + number + ") - " + (city ?? "**") + base.ToString() + "]" ;

and the following objects in the database:

private static void InsertData()
     using (IObjectContainer db = Db4oFactory.OpenFile(DATABASE_FILE))
         Person grandParent = new Person("Joseph", 65, new Address("Descalvado", "JV street", 160), null);
         Person father = new Person("Adrian", 36, new Address("São Paulo", "C. L. E. M. street", 250), grandParent);
         Person child = new Person("Caroline", 4, new Address("São Paulo", "C. L. E. M. street", 250), father);


The following image shows the result when querying for "Car
oline" at different activation depths (with Transparent Activation disabled):

Note that at depth 0 (zero) only the object identifier for "Caroline" (1336) was loaded from the database; at depth 1 Caroline's value types were fully loaded and reference fields were initialized (to null) but not activated (see Caroline's address and parent fields). At depth 2 Caroline's parent object was also loaded (and activated) but its reference fields (for instance Caroline's grand father) were not activated yet.

Related Concepts

The same trade-of (simplicity/performance) applies when updating objects in a db4o database; I mean, usually you'll not want to update the whole set of objects reachable from the one you are currently updating because this would probably end up updating a lot of objects needlessly. To control this behavior you may configure the update depth through IConfiguration.UpdateDepth() method which takes an integer meaning how deep db4o will go when updating objects (keep in mind that when inserting, db4o will follow all references and insert all of then). This configuration may be globally (i.e, to all classes) or selectively applied (i.e, to specific classes). As of the current version db4o sets the default update depth to 0 that means that only value types and strings fields will be updated when an object is updated (i.e, reference fields will not be updated). Optionally it's possible to propagate updates to all objects reachable from the object being updated by configuring cascade on update for the specific classes you want to propagate updates.


When configured this way, db4o will go down, updating all objects reachable from your_type until it reaches an object not configured for cascade updating (note that this may impact performance severely if this object references a lot of objects also configured for cascade updating).

Transparent Activation

Transparent Activation is a functionality that enables developers to handle objects returned by queries as if they were fully activated without incurring the cost of activating a whole graph of objects. In other words, when TA is enabled, developers may code as if activation depth was set to infinity without having to worry about the whole set of objects being loaded into memory. Basically, Transparent Activation transfers the responsibility of object activation from developers to db4o allowing them to focus on their business logic.

Configuring your db4o projects to use TA is 2 steps process:

  • Configure TA support (prior to opening the database):

    IConfiguration.Add(new TransparentActivationSupport());

  • implement IActivatable interface in classes you want to be TA aware.

    You can implement it by yourself or let us (ok, our tools) to do this work for you through Db4oTool (the old Db4oAdmin) application.

Keep in mind that when transparent activation support is enabled IConfiguration.ActivationDepth() is ignored; also, all objects that are note TA aware (i.e, that doesn't implement IActivatable interface) will be fully activated; so, we don't recommend to enable TA if you have lots of objects that doesn't implement this interface. While activating objects db4o will stop following references as soon as it reaches an TA aware object (after all it will be activated when needed).

More technical details about TA can be found here and a full sample along with details about it can be found here.

Putting it all together

Here you can checkout the sample application that shows the points discussed above. It inserts a simple graph of objects into a database and then queries for the root of the objects using different activation depth configurations. Also, you can ask the application to pretend that it's objects supports TA through the -ta command line option.

I recommend you to download it and do the following:

  • Poke around, looking into the code :)
  • Give it a try, i.e, run it without any parameter and see what you get;
  • Try to run it again, but this time passing -ta parameter, and, again, see what you get;
  • Make its classes TA aware (see here the easy way) and try to run it with and without -ta parameter.

If you have any question don't hesitate to ask them here!


Nov 20, 2007

Old news from the front!

Visual Studio 2008 has been released (Yep, I'm downloading it right now :) Niiice.

Oct 24, 2007

Do you fear ghosts?

Well, me too, at least until one month ago :) Seriously, a long time ago (maybe not so long), Rodrigo, a great friend of mine, started talking about write a new language for the .Net platform. Of course, I promptly ignored him, after all, who needs another computer language? Some time passed and I started to hear about a new language called Boo. I was so deeply entrenched in my own world that it took me some time (and some books also :) to realize that that would be great to be exposed to a lot of new concepts (at least to me). Well, yesterday I've wrote my first Boo program! Sure, it's a humble one but it's a start. In order to learn (not only the syntax, but a lot of concepts such closures, ducking typing, etc.) I'll try to write more code using boo from now on :) And for those curious minds out there, here is my first piece of Boo code :)
def Sum(list):
 ret = 0
 for value as int in list:
    ret = ret + value
 return ret

list = (1, 2, 3, 4)
for v in list:
print Sum(list)
This is really very simple: Lines 1 ~ 5 defines a function called Sum. Line 7 declares a variable (list) that holds an integer list from 1 to 4 Lines 8 ~9 prints this list to console, item by item Line 11 prints the result of Sum when called with list as the argument. Thats it. Adriano

Oct 8, 2007

Enabling transparent activation in your db4o applications

As a software developer, one common pattern I've found over and over again is the typical parent/child relationship.

In this post I'll present you a program
(a WinForms based application) that lets you create, store and delete objects (representing tasks) that follows this common structure in a db4o database and take the opportunity to show how a new db4o feature (to be introduced in our next release) helps to solve some related problems.

Obs: I'll focus on the .Net side of db4o but these concepts apply equally to our Java interface. Also, in order to be able to access various links related in this post you'll be required to join (for free) the "db4o Developer Community"; it's a very simple process: just click on join when asked for your credentials (user name/password).

Ok, let's use the application for while ...

Open TaskSample.sln solution in Visual Studio 2005 (it should also work on the Express Edition) and compile it. Then, launch it and add some tasks by pressing "CTRL-A" or selecting "Tasks/Add.." menu.

Now add some tasks as the following structure ...

  • Work
    • Todo
    • Projects
      • Super hyper ultra mega project
        • Components
          • GoldenHammer.dll
            • GoldenNail.dll
            • GoldenHead.dll

... close the database selecting "File/Close" in the main menu ...

... and reload it (select "File/Open") .

Now expand the tasks in order to see "Super hyper ultra mega project" sub tasks.

What? What happened to Components, GodenHammer.dll, GodenNail.dll and GondelHead.dll? Where are they?

Take it easy; I assure you that db4o didn't ate your task objects :) What happened is that our old friend, the cost/benefit trade-off is showing its ugly head.

In order to keep memory consumption low and object throughput high, db4o sets a hard limit
on "how deep the rabbit hole goes" (a concept called activation depth), or, in other words, how many levels it is willing to go down in the object graph reading (activating) them from the database.

It just happens that in its current version, db4o sets this limit to 5, i.e, starting from each object directly selected by a query, at most 5 levels bellow will be returned.

That explains why the sub tasks were not loaded from the database.
(they are six levels down the root task so db4o stopped following references when it reached the "Super hyper ultra mega project" task.

How can we ensure smooth operation of our application?
  1. setting the activation level to a higher value might be an option (but which value? small values will activate too little objects; higher values may lead to high memory consumption and possibly out of memory exceptions):
    IConfiguration configuration = Db4oFactory.NewConfiguration();
    using(IObjectContainer db = Db4oFactory.OpenFile(configuration, Db4oFileName))
    // perform some work here

    To test this option, select a higher activation depth (let's say, 8) in the sample application; the database will be reopened; now you'll be able to see all the tasks :) For more details about activation depth, please, see here.

  2. Manually activating objects as needed;

    In this scenario we may track expansions in out task treeview and activate them as needed.
    db.Activate(task, 1);

    To test this option select the "Enables automatic activation" button on the toolbar (the little bulb lamp). The database will be reloaded and now you'll be able to see all tasks again.

  3. Or, IMHO, the best one, letting db4o take care of this through Transparent Activation (herein referred only as TA), a new feature to be introduced in our next release (download the latest development build here) (for more details and samples about this feature look here and here);
Note that in order to benefit from TA (solution 3) objects must implement IActivable interface, either explicitly or through instrumentation as explained here.

I recommend following the instrumentation path (let the computer do the dirty work for us :). Db4o ships with an utility program (Db4oTool.exe) that you may use among other duties, to instrument assemblies to support TA.

All you need is to call Db4oAdmin.exe after building your assemblies and it'll add the required pieces to support TA.

Db4oTool -ta assembly_name.ext

If you prefer, add a post build step to TaskSample.snl project as follows:

\db4o-8.0\bin\net-3.0\Db4oTool.exe -ta "$(TargetPath)"
In order to instrument signed assemblies you'll need to delay sign them (because instrumentation process changes the assembly). For more information about delay signed assemblies, please, refer to this msdn article.

The application title bar shows you if the application was instrumented or not (if it supports TA or not).

Try to play with the sample and check the results. You may download the sample (source files) for this post here.

Thank you and see you soon ;)


Oct 6, 2007

New challenges.

This week I've joined db4objects team to contribute with the .Net development side (but I'm pretty sure I'll do a lot of Java development also). Indeed it has been a busy week; lots of new concepts and code to get to know, new management style, new tools, etc. I'll be working from my home (cool!!), collaborating with a distributed (talented) development team through skype. Some may call me crazy but db4objects have a cool product to work with and this opportunity will let me dedicate more time to my family, to study new topics (related to computers, of course), to watch movies, etc (I know, studies proved that working in home means to work more, but I'll get some spare time cause I'll not be required to go to jammed traffic :) Also, you can expect to see more posts on this blog covering db4o ;) Well, that's it. Adriano

Sep 18, 2007

Minor db4o tutorial problem

Some time ago I started playing with db4objects, an object oriented database for Java and .Net.

After installing db4o it started this tutorial (C:\Program Files (x86)\Db4objects\db4o-6.3\doc\tutorial\Db4objects.Db4o.Tutorial.exe, on my 64 bits Windows Vista Box) and everything went as smooth as possible but, when I tried to restarted it in the next day, it failed and the following dialog was shown:

Looking at this dialog we can see that the program failed to delete a file called formula1.yap under C:\Program Files (x86)\Db4objects\db4o-6.3\doc\tutorial\ folder; so I launched Process Monitor and pushed Reset button in tutorial program again.

It just confirms that the tutorial is failing to delete the file but why? Worse, why have it worked when we started it for the first time?

The .Net tutorial that comes with db4o has some minor bugs related to the way Windows Vista x64 handles writes to some specific paths, more specifically to %ProgramFiles% and %ProgramFiles(x86)% folders.

It's a Windows Vista feature called UAC (for detailed information about this topic please refer to this technet article) that prevents standard users (non administrators) from writing to some folders/registry keys, basically to keep the system more stable and secure. Actually it worked in the first time because

Ok, so how to fix this problem?

Basically there are 3 different approaches that can be applied:
  • The "Quick and Dirty" way (probably the easiest and fastest one) is to run the tutorial as an administrator. To do this just right click on the tutorial program and select "run as administrator".

  • The second one consists in adding a manifest next to the tutorial program ( (warning: Windows Vista/.Net will cache the tutorial program and will not pick you fresh manifest :(. In this case you can just "touch" the tutorial program -- or move it to another folder -- and Windows will load the manifest in the next time you start it as explained here). This simply instructs Windows to start the program with administrator rights.

  • The last one (and in my opinion the correct one) consists in fixing the tutorial in order to save this file under %LocalAppData% (or %AppData%) instead of its installation folder (thats the recommended action by Microsoft).

That's all folks ;)

In a future post I'll discuss a bit more about a UAC feature called File System and Registry Virtualization and why it wasn't applied in this case.

Sep 10, 2007

Another post in the series RTFM :)

As I've said in my last post, I'm reading C# 3.0 specification. Well, it's amazing what you can learn when you do take the time to learn more about the tools (in this case, the language) you use all day long :). This time I've find out that it's possible to use reserved words as identifiers! Amazing! (and of course, dangerous as it make it harder to read your code.) But this isn't a new feature of C# 3.0; it works with C# 2.0 (.Net Framework 2.0)! Just copy the following sample and compile it using CSharp compiler from .Net Framework 2.0!
public class @class
   private static void Main()
      int @int = 10;
      int @delegate = @int + 30;;
      System.Console.WriteLine("Values {0} {1}", @int, @delegate);
What do you think about using reserved words as identifiers? Let the world know your opinion! :) Adriano

Sep 4, 2007

?? Operator.. What is it good for?

Hi, Other day I was poking around C# 2.0 documentation and noted a different operator I had never seen before, ?? so I thought with myself: what is it good for? Well, after reading the documentation (remember, RTFM :) I couldn't believe I didn't known this before! The ?? operator is a binary operator that checks the left operand against null. If it is null, the expression result is the right operand value otherwise (left operand is not null) it will be the left operand value. See a sample:
string name = null;
Console.WriteLine("Value: {0}", name ?? "(null)"); // Writes: Value: (null)

name = "Adriano";
Console.WriteLine("Value: {0}", name ?? "(null)"); // Writes: Value: Adriano

Also, it is useful when used in conjunction to nullable value types.
int? i = null;
Console.WriteLine("Value: {0}", i ?? -1); // Writes: Value: (null)

i = 20;
Console.WriteLine("Value: {0}", i ?? -1); // Writes: Value: 20
PS: I've just started to play with
C# 3.0 (Visual Studio 2008 beta 2) and it seams to be a very strong language. PS2: Finally I managed to get SyntaxHighlighter to work with blogger (thanks to this post) As soon as I got more information I'll post my impressions here :) See you soon!


Depois de ponderar algum tempo sobre o assunto estou considerando utilizar o inglês nos próximos posts. Porque esta decisão?
  • Basicamente entendo que a maioria das pessoas que possam vir a se interessar pelo conteúdo deste blog não teriam problemas para ler conteúdo (pelo menos técnico) em inglês.
  • Escrever em inglês me ajudaria a melhorar meus conhecimentos neste idioma.
  • Adotar o inglês tornaria este blog mais acessível a outras pessoas que não conhecem o português
Se você acompanha este blog e prefere que o conteúdo continue em português deixe um comentário. Dependendo do número de pessoas posso não mudar para o inglês ou então posso postar nos dois idiomas :) Adriano.

Aug 28, 2007


Já faz algum tempo que não posto nada... o motivo, como todos já devem saber, é a absoluta falta de tempo, afinal de contas, tenho que me dedicar à obra de Deus, minha esposa, filha e aos jogos (need for speed rules!) ;) Como estou um pouco sem tempo para escrever um post mais interessante vou apenas listar algumas coisas com a qual tenho me envolvido atualmente:
  • Object Mocking em .Net (comecei a utilizar o Rhino.Mocks)
  • OODB, ou seja, Object Oriented Databases (estou estudando o DB4O)
  • Estou escrevendo um artigo sobre um dos novos recursos do Windows Vista (e também do Windows Server 2008), o KTM, ou, gerenciador de transações do Kernel, para uma revista sobre .Net.
  • Lendo alguns livros, principalmente um sobre WCF.
  • Etc.
É mais ou menos isso :) []'s Adriano

Jun 15, 2007

Stream de dados alternativas

Para muitos usuários (e mesmo desenvolvedores) do Windows o conceito de arquivo esta tão sedimentado que muitas vezes melhorias significativas no sistema de arquivos deste sistema operacional (no caso o NTFS) são ignoradas.

Neste post apresento um dos recursos mais desconhecidos, stream alternativas de dados ou ADS (do inglês, Alternate Data Stream).

Para compreendermos este recurso é necessário primeiro definirmos (ou relembrarmos) alguns conceitos:

  • Uma stream de dados nada mais é que um conjunto de bytes arranjados de forma seqüencial.
  • Um arquivo é composto por uma ou mais streams de dados.
  • Streams de dados possuem um nome associado através do qual a mesma é referenciada. A regra básica para formação do nome de streams é: nome-arquivo.ext:nome-stream:tipo-stream
  • O nome da stream pode conter qualquer caracter válido para um nome de arquivo.

Como o Windows não possui meios (tanto no Explorer quanto no console) para detectar / mostrar arquivos que possuem ADS, abaixo listei algumas ferramentas úteis para tal finalidade:

Usando ADSs

A forma mais simples para demonstrarmos este conceito é através do console do Windows. Abra o console (cmd.exe) e digite:

echo teste de streams > teste.txt:dados

Simples assim! O comando acima cria uma stream chamada dados com o conteúdo teste de streams.

Agora você pode conferir que o arquivo teste.txt foi criado mas o comando dir reporta o mesmo com 0 (zero) bytes.

Finalmente, para visualisar o conteúdo da stream digite

more < teste.txt:dados

Abaixo apresento um pequeno programa de exemplo para criar ADSs (note que o mesmo não possui nenhum tratamento especial, ou seja, a forma de acessar data streams alternativas é idêntica à utilizada para acessar a data stream default).

#include "stdio.h"
#include "Windows.h" 
void main(int argc, char *argv[])
    HANDLE handle;
    if (argc < 3)
        printf("Nome da stream (formato: arquivo.ext:stream) ou dados nao especificados.\r\nUso: ads.exe nome-stream dados");
        printf("\r\nGravando dados em %s", argv[1]);
    handle = CreateFile(argv[1], 
                        0, 0);
    if (handle != INVALID_HANDLE_VALUE)
        DWORD numberOfBytesWritten;
        int n = WriteFile(  handle, 
        printf("\r\n%ld bytes gravados", numberOfBytesWritten);
        printf("Não foi possivel criar a stream de dados.");
[Editado: Correção de um erros de português]

experimente executar o programa com alguns parâmetros como por exemplo:

ads teste.txt:dados "Teste de streams"

É isso ai.

Até a próxima.

May 15, 2007

Boa leitura

Em se tratando de informática, ou mais especificamente de desenvolvimento de software, existem algumas ótimas publicações que podem ser lidas online (algumas delas podem ser baixadas), e o melhor, gratuitamente. É claro, que leio pelo menos uma dúzia de blogs e outras publicações (sem contar livros :) além destas! Adriano

May 11, 2007

"COM" não esta morto (pelo menos eu espero)

Assim como a morte de linguagens de programação como Cobol, Fortram, Basic, etc. e também a extinção dos programadores já foram anunciadas várias vezes, mas nunca se concretizaram ,graças a Deus, muitos já anunciaram a morte do COM (Component Object Model), uma tecnologia da MS para a componentização de soluções. Infelizmente (para estes "gurus" !) isso não aconteceu (preciso dizer: "eu já sabia que isso não aconteceria mesmo") ? Pelo contrário, se você observar o número de sub-sistemas do Windows Vista implementado usando esta tecnologia você irá notar um aumento razoável no número de componentes neste SO. Como grande parte da minha carreira foi dedicada a esta tecnologia é natural que eu tenha interesse nesta :). Assim, a alguns anos atrás (para ser mais preciso, entre 2002 e 2004), eu escrevi (e disponibilizei gratuitamente) um utilitário (ao qual chamei de Typelib Wizard) que, entre outras coisas, permite fazer Browse do conteúdo de TLBs (quer estas TLBs estejam isoladas ou incluídas como recurso de um executável) mais ou menos nos moldes dos browsers de classes encontrados nos ambientes de desenvolvimento atuais. Se você desenvolve componentes COM (ou se utiliza ambientes tais como ASP (não ASP.NET), VB 6, VBA, Power Builder, etc., em que a chance de estar utilizando componentes COM, mesmo sem saber, é grande) esta ferramenta é de grande utilidade. A algum tempo eu não realizo nenhuma manutenção no projeto mas tenho algumas idéias e seria um prazer adicionar outros desenvolvedores para que os mesmos possam atualizar o repositório de código (que aliás, vou passar para o subversion) e ajudar a manter o projeto "andando". Para saber mais sobre o projeto visite os sites abaixo: Abraços. Adriano

Feb 28, 2007

SerialWizard: Uau! 1649 Downloads (1 Gb!)

Quando comparado com outros aplicativos pode não parecer muito, mas para mim realmente é um número expressivo: o SerialWizard já foi baixado 1649 vezes totalizando 1 Gb ! Se tiver curiosidade para saber como o SerialWizard esta neste momento click aqui.

Descubra mais sobre você !

Hoje (como de costume) estava lendo alguns blogs e me deparei com um site muito interessante; neste site você responde algumas perguntas e ele lhe diz qual "super heroi/vilão" você é! :). Veja os meus resultados:
You are Mr. Freeze
Mr. Freeze
The Joker
Dr. Doom
Lex Luthor
Dark Phoenix
Green Goblin
Poison Ivy
You are cold and you think everyone else should be also, literally.
Click here to take the "Which Super Villain are you?" quiz...

You are Green Lantern
Green Lantern
Iron Man
The Flash
Wonder Woman
Hot-headed. You have strong
will power and a good imagination.
Click here to take the "Which Superhero am I?" quiz...
Neste site você pode descobrir qual SO você é :)
You are Debian Linux. People have difficulty getting to know you. Once you finally open your shell they're apt to love you.
Which OS are You?
Neste site você pode descobrir qual linguagem de programação você é :)
You are Python You are slower than others, but easier to understand. You are a minimalist, who doesn't like clutter.
Which Programming Language are You?

Finalmente qual extensão de arquivo você é!
You are .exe When given proper orders, you execute them flawlessly. You're familiar to most, and useful to all.
Which File Extension are You?

Feb 22, 2007

COM/COM+ ? Alguém ta afim?

Você desenvolve, ou conhece alguém que desenvolva, componentes COM/COM+? Integrando com o SNA/HIS server? A algum tempo atras eu já não encontrava muitas pessoas que conhecessem e/ou desenvolvessem usando COM/COM+; agora parece mais difícil ainda! Bom, pelo menos a MS ainda utiliza estas tecnologias de forma extensiva, visto que no Windows Vista o número de componentes COM aumentou :). No meu último emprego (em uma instituição financeira) utilizávamos muito componentes COM+ integrados com o HIS Server. Motivado pela instabilidade do nosso ambiente de testes (e outras coisas mais) iniciei o desenvolvimento de um mecanismo que nos permitisse "simular" a interação com o mainframe (ou seja, passar pelo SNA/HIS server) que acabou por tomar formas mais genéricas e permitir que uma grande gama de componentes COM/COM+ fossem passíveis de ser simulados. Abaixo apresento algumas das vantagens que este mecanismo apresenta:
  • Independência do mainframe (poderíamos continuar nossos testes mesmo que nosso ambiente de testes do mainframe estivesse parado)
  • Flexibilidade para realizar unit tests uma vez que, dado um conjunto de dados de entrada, poderíamos retornar qualquer valor desejado.
  • Simplicidade de configuração
Infelizmente não tive tempo hábil para terminar este projeto (que basicamente é dividido em dois módulos: i) um componente COM/COM+ cuja responsabilidade é simular outros componente; ii) um aplicativo GUI responsável por configurar/monitorar a utilização do componente) antes de me desligar desta instituição financeira e, no momento, não estou utilizando tanto componentes COM/COM+ para justificar o investimento necessário para finalizar o projeto junto a empresa que trabalho atualmente. O objetivo deste post é definir se há pessoas interessadas em continuar o projeto; eu poderia colocar o fonte no sourceforge (qualquer um poderia baixar os fontes) e incluir os interessados como desenvolvedores do projeto (estas pessoas poderiam fazer "commit", ou seja, atualizar os fontes no sourceforge. É claro que eu daria suporte :) Se alguém tiver interesse comente neste post e podemos discutir melhor como seria o processo. Até mais. Adriano

Jan 24, 2007

User Interface Design

Se você participa do design, desenvolvimento, teste, documentação, etc. de programas não deixe de ver esta série de artigos (na realidade os capítulos do livro do autor do blog) sobre design de user interfaces. Mesmo que estando incompleto (o autor disponibilizou alguns capítulos apenas) eu recomendo a leitura do texto. Adriano