Off-notes off the Mind

The role of a team lead in agile environment

2008-01-21T19:48:00.000+06:00

I think pure waterfall model is impractical. It is as impractical as the pendulum in pure physics where the thread is of no weight and no friction exists. And that is what you can never have in the lab.

We, the software developers know there is always 'friction' and nothing is 'massless'. The ever changing nature of the human mind and limitation to perceive what it needs results in modification in the requirement. That why we are agile, we don't just fall.

Now, trust and sense of responsibility are at the base of agile methodologies among some other. Here, every member in a team is expected to be self driven and self motivated. They are given task and set free to accomplish that at their own choice. Formal managing, let alone macro managing, hardly gets its place. Then what would the team-lead do ? Should s/he dive into developing? or is there indeed any need of a team leader?

Actually, there is an unavoidable need of the team-lead-role. And s/he should never dive into developing unless it is that required. Rather, he(please add an 's' before 'h', I'm lazy.) role is to keep all his mets connected as well observe aspect of their work.

Team-Lead role is almost similar to the role of the wicket keeper in cricket; cheering up the players and catch all the balls behind. A team lead should also look for the quality and security of the code component. As well, he will also ensure development path is not deviated from the path. As we are talking about agile methodologies, change may come, but that change should be verified by the team lead.

Besides, the team lead should accumulate the knowledge learned by each of the team members. He is to somehow implement the notion of adaptive software development(ASD proposed by Jim Highsmith) i.e. focus on collaboration and learning. He is to arrange an meeting to share the knowledge of the team mets. It can be in lunch time, can be after lunch hour or whenever seems appropriate. Remember, there is no need to prepare presentation as it often time consuming and deviates the concentration from the development. Main idea is to use any wheel if developed already by a team.

One point must be concerned about at this regard is to maintain the motivation and positive team spirit. Say two techniques are developed by two of the team members for similar type of problem. Both the developers are smart and techniques are smart too. Now, to server in future which method is to be used? The team lead should carefully analyze(don't take too much time, if not resolved drop it till a right time) the two techniques with participation of them and expectedly he should sort out the right one and has to convince both of them positively.

Always keep in concern to maintain the team spirit and motivation.

Books I have read.

2008-01-20T18:11:00.000+06:00

Reading is my hobby and forgetting is my nature. In continuation to this, I have just started reading the book "Agile Software Development Qauality Assurance" by Ioannis Stamelos and Panagiotis Sfetsos.

Recently I was very much inspired by Hasin Hayder to read on, since that, I like to share my reading experience.

This post will contain all my read books gradually :)

1. Agile software development quality assurance
by Ioannis G. Stamelos, Panagiotis Sfetsos

2. Test-Driven Development By Example
by Kent Beck

3. Software engineering A practitioner's approach
by Roger S. Pressman

4. Object-oriented PHP, concepts, techniques and code
By Peter Lavin

JQuery

2008-01-13T00:53:00.002+06:00

Once it used to be stated that to be a good developer one should learn a language every year. Why? The basic reason was to widen up ones view. By learning new language we can come to know about new techniques to solve a problem. Following that rule, I tasted some languages like C/C++(:P), java, Perl, PHP VB, Bash, VRML, JavaScript, C#, VC++/MFC(it should fall in C++ !), Flash Action script, SQL, Ferite etc.

Now, should I start learning python or ruby? I know they worth knowing, those are suppose to be a pleasant experience. But, what else might be done? I think knowing some api/libs can do the same! So, we learn GTK, XFC, Enlightenment, JFP, Struts, Tapestry etc.

In this way, I have started tasting JQuery. I am not saying learning, as to 'learn'or to say "I know THIS" not just means I read few books, some articles and a handful of codes to demonstrate, rather it's a matter of a longer period than 24 hours or 30 days.

Anyway, I am just writing about what I understand while going through the journey with JQuery( JQ ). Btw, I am studying the book, "Learing JQuery" by Jonathan Chaffer and Karl Swedberg.

What we can do with JQ:

Easily access to any DOM element
Modify the appearance on the fly [using css]
Change the content of the page
A wide range event handling to make the page more responsive to the user

Besides these using jq we can do animation on the page,

ajax

integration and simplify other javascript tasks.

JQ has an interesting factory function $() and it can refer to any object very easily, like:

Elements : $('p') : Gets all the paragraphs
A particular element: $('#an_id'): gets the element with id 'an_id'
Elements with same class: $('.className')

[to be continued, feeling sleepy..]

When captain want to score

2007-12-07T17:16:00.001+06:00

It is a post in reply to SQABD Yahoo group.

Really a nice statement, there is no 'I' in TEAM.

In addition to it, I would like to say, "...though it is consisted of
some I's". And everyone, really need to be concerned about all the I's.

Why I am saying this, is for another truth that you said about team
sport. Yes, surely someone gets more credit. Say in foot ball, may be
the scorers are highlighted. But if the scorers want to play alone it
is not appreciated and can be risky; as we all know it will also
hamper the team effort.

Additionally, think about the case when the captain is always planning
how to score himself and forgets to plan how to defend his back, or
how to employ all the players for winning the match, in software
development context, meet the deadline and keep the project and make
the customer happy :)

Though, in some organizations and in some teams, it is experienced
that some members irrespective of his/her role often forget their
play.Sometimes they fail to understand the difference between
confidence and (superiority)complex. It is rather detrimental when it
happens to the captains.

Specially the captains who came up to the managerial level by his/her
development talents, which is undoubtedly appreciable. But
occasionally, they are found to give more concentration on
development(not design) rather on managing. As a consequence,
developers kept idle. There are even some situations where developers
were kept idle for 5+ hours for a 2 decision of the skipper(and it was
solved in 10min after that), why ? cause s/he was coding in quiet
mode! And it was not use to happen occasionally, rather it was a
everyday practice! Developers working late nights often had to wait
for hours together for a decision.

Moreover,another problem of captains who were a Ronaldo(I'm his
fan!)once is frequently found in their initial planning and designing
the system. They tends to concentrate(and confined in the box) more on
development details. I had another experience, where the manager was
very talented and designed an system architecture(it was really a
nice, I admit) and made the developers write more than 60 classes! But
the problem was s/he did not know which technology/api will be used.
When the api is got along with the apidoc, all those piles of codes
are kept aside for the dust to fall on and with a hope to use in
future. Developers again started writing code when they come to know
what to do after sitting idle for hours. And again, the captain uses
his/her full talent to develop some roadblocks (definitely those were
very important) but without an integration plan and guess what... even
without a revision control system. So the developers started writing
the drama, which was scattered and scary.....

So I think, though the word TEAM has no 'I' in it but it has an 'M' at
the lead. S/he must ensure and be concerned that there comes no 'I' in
TEAM.

Have a nice day !

NetBean, even more fun

2007-11-22T17:10:00.002+06:00

I am not going to raise another holly war between netbeans and the eclipese IDE. But, even though eclipse ide worked great after little tweaking, i think everything work better after they are tweaked, I love netbeans for its simple and fast interface. I know, many of you already frowned as called netbeans fast ! Yes indedd. At least for C/C++ development. Netbeans appeared simply lightening fast. It easily replaced geany as my favorite IDE.

It is true, eclipse user base is very rich and so is its plug-in base. Almost all the necessary tools along with huge unnecessary ones (for a particular development view) can be found with eclipse. Especially the subversion plug-in... it is simply splendid). No worries.. I will download the svn module for netbeans. Hope it will not dishearten me :)

Lastly, I also admit, netbeans is very slow for java development. Last time I was developing a non-day-job project using jsp/struts. I choose netbeans and found that it takes all the memory of my computer. Again after tweaking for memory, it came up with much faster speed, even though an honest comment will be . SLOW.

But, if for C++ development, its simply great. Additionally, you can easily create UML design graphically by drag and drop; and then use it in your project ! One interesting feature of the UML module is that, here some of the design pattern templates are built in i.e. just select a pattern, give custom name click ok... you got the classes.

Finally, I am very happy with the new netbean.. I simply love it.

Using Eclipse is Fun !

2007-11-22T17:10:00.001+06:00

My current project is about building an embedded software using C++ on a ARM board. Due to some reasons we had to use use Eclipse as we are to use a proprietary tool chain plug-in of the editor. Anyhow, eclipse was too slow to proceed development work fast where deadline is always yelling at the ear and release are very frequent. I started use geany, my favorite editor, for writing codes and just used Eclipse to build the project.

Tonight, I got some relax time(you know 36 degree centigrade is cooler than 40 degree centigrade ! ) and played with eclipse settings. I just stopped the indexer and some other auto completion options -- the result was out of expectation ! Eclipse became fast enough to code on :) Besides, for source code I like courier font, so I did not miss to change that too.

Now, if you are interested, go to Window->Preferences->C/C++ and set off the content assistant and indexer. Bingo... now you have a faster Eclipse.

C++ Member initialization

2007-11-09T17:12:00.000+06:00

Many of us may not know that member variables of a class object is initialized before the body of the constructor is executed! The class type members are initialized with the default constructor i.e. constructor with no arguments. Primitive type member variable like int, float etc does not have any constructors, so they are just initialized with an undefined initial value which is often a garbage.

Anyhow, this behavior can be changed ! While defining the constructor to initialize the member variables with desired values put a colon after the constructor's last first-bracket and initialize the member variable placing a pair of first bracket after each member name; don't forget to put the value in between the first brackets. Both the class and primitive type members can be initialized in this way. Here is an example:

class A{
string m_name;
int m_id;

public:
A(int id);
A(int id, string& name);
};
/////
A::A(int id):m_id(id),m_name("No name")
{}

This is a faster way than initializing the member variables in the constructor with assignment operator. Because for the later case member variables are first initialized with their respective default garbage values than assigned with the desired values; whereas in later case they are simply initialized with the desired values !
:)

Play game here

2007-10-30T17:15:00.000+06:00

Just added 2 free games from DynamicDrive. I love this site for its great resources. Besides, I added fading effect to pop up the game div at center. You can now play these games from this page, just click any of the game link from the top left menu !!

Would you please play once and put your scores on comment ? :)

Thanks for your encouragement.

Macadamian's Code Review Checklist

2007-10-25T18:49:00.000+06:00

At Macadamian, we practice what we preach with peer code reviews. Before we commit any code to source control, we check it for compliance with this list.

We’ve made the checklist public for the use of software development teams implementing code review as part of their process. For more information about code review processes and software development best practices, read check out the Critical Path newsletter – it’s free, too!

General Code Smoke Test
Comments and Coding Conventions
Error Handling
Resource Leaks
Control Structures
Performance
Functions
Bug Fixes
Math

General Code Smoke Test

Does the code build correctly?
No errors should occur when building the source code. No warnings should be introduced by changes made to the code.

Does the code execute as expected?
When executed, the code does what it is supposed to.

Do you understand the code you are reviewing?
As a reviewer, you should understand the code. If you don't, the review may not be complete, or the code may not be well commented.

Has the developer tested the code?
Insure the developer has unit tested the code before sending it for review. All the limit cases should have been tested.

Comments and Coding Conventions

Does the code respect the project coding conventions?
Check that the coding conventions have been followed. Variable naming, indentation, and bracket style should be used.

Does the source file start with an appropriate header and copyright information?
Each source file should start with an appropriate header and copyright information. All source files should have a comment block describing the functionality provided by the file.

Are variable declarations properly commented?
Comments are required for aspects of variables that the name doesn't describe. Each global variable should indicate its purpose and why it needs to be global.

Are units of numeric data clearly stated?
Comment the units of numeric data. For example, if a number represents length, indicate if it is in feet or meters.

Are all functions, methods and classes documented?
Describe each routine, method, and class in one or two sentences at the top of its definition. If you can't describe it in a short sentence or two, you may need to reassess its purpose. It might be a sign that the design needs to be improved.

Are function parameters used for input or output clearly identified as such?
Make it clear which parameters are used for input and output.

Are complex algorithms and code optimizations adequately commented?
Complex areas, algorithms, and code optimizations should be sufficiently commented, so other developers can understand the code and walk through it.

Does code that has been commented out have an explanation?
There should be an explanation for any code that is commented out. "Dead Code" should be removed. If it is a temporary hack, it should be identified as such.

Are comments used to identify missing functionality or unresolved issues in the code?
A comment is required for all code not completely implemented. The comment should describe what's left to do or is missing. You should also use a distinctive marker that you can search for later (For example: "TODO:francis").

Error Handling

Are assertions used everywhere data is expected to have a valid value or range?
Assertions make it easier to identify potential problems. For example, test if pointers or references are valid.

Are errors properly handled each time a function returns?
An error should be detected and handled if it affects the execution of the rest of a routine. For example, if a resource allocation fails, this affects the rest of the routine if it uses that resource. This should be detected and proper action taken. In some cases, the "proper action" may simply be to log the error.

Are resources and memory released in all error paths?
Make sure all resources and memory allocated are released in the error paths.

Are all thrown exceptions handled properly?
If the source code uses a routine that throws an exception, there should be a function in the call stack that catches it and handles it properly.

Is the function caller notified when an error is detected?
Consider notifying your caller when an error is detected. If the error might affect your caller, the caller should be notified. For example, the "Open" methods of a file class should return error conditions. Even if the class stays in a valid state and other calls to the class will be handled properly, the caller might be interested in doing some error handling of its own.

Has error handling code been tested?
Don't forget that error handling code that can be defective. It is important to write test cases that exercise it.

Resource Leaks

Is allocated memory (non-garbage collected) freed?
All allocated memory needs to be freed when no longer needed. Make sure memory is released in all code paths, especially in error code paths.

Are all objects (Database connections, Sockets, Files, etc.) freed even when an error occurs?
File, Sockets, Database connections, etc. (basically all objects where a creation and a deletion method exist) should be freed even when an error occurs. For example, whenever you use "new" in C++, there should be a delete somewhere that disposes of the object. Resources that are opened must be closed. For example, when opening a file in most development environments, you need to call a method to close the file when you're done.

Is the same object released more than once?
Make sure there's no code path where the same object is released more than once. Check error code paths.

Does the code accurately keep track of reference counting?
Frequently a reference counter is used to keep the reference count on objects (For example, COM objects). The object uses the reference counter to determine when to destroy itself. In most cases, the developer uses methods to increment or decrement the reference count. Make sure the reference count reflects the number of times an object is referred.

Thread Safeness

Are all global variables thread-safe?
If global variables can be accessed by more than one thread, code altering the global variable should be enclosed using a synchronization mechanism such as a mutex. Code accessing the variable should be enclosed with the same mechanism.

Are objects accessed by multiple threads thread-safe?
If some objects can be accessed by more than one thread, make sure member variables are protected by synchronization mechanisms.

Are locks released in the same order they are obtained?
It is important to release the locks in the same order they were acquired to avoid deadlock situations. Check error code paths.

Is there any possible deadlock or lock contention?
Make sure there's no possibility for acquiring a set of locks (mutex, semaphores, etc.) in different orders. For example, if Thread A acquires Lock #1 and then Lock #2, then Thread B shouldn't acquire Lock #2 and then Lock #1.

Control Structures

Are loop ending conditions accurate?
Check all loops to make sure they iterate the right number of times. Check the condition that ends the loop; insure it will end out doing the expected number of iterations.

Is the code free of unintended infinite loops?
Check for code paths that can cause infinite loops. Make sure end loop conditions will be met unless otherwise documented.

Performance

Do recursive functions run within a reasonable amount of stack space?
Recursive functions should run with a reasonable amount of stack space. Generally, it is better to code iterative functions.

Are whole objects duplicated when only references are needed?
This happens when objects are passed by value when only references are required. This also applies to algorithms that copy a lot of memory. Consider using algorithm that minimizes the number of object duplications, reducing the data that needs to be transferred in memory.

Does the code have an impact on size, speed, or memory use?
Can it be optimized? For instance, if you use data structures with a large number of occurrences, you might want to reduce the size of the structure.

Are you using blocking system calls when performance is involved?
Consider using a different thread for code making a function call that blocks.

Is the code doing busy waits instead of using synchronization mechanisms or timer events?
Doing busy waits takes up CPU time. It is a better practice to use synchronization mechanisms.

Was this optimization really needed?
Optimizations often make code harder to read and more likely to contain bugs. Such optimizations should be avoided unless a need has been identified. Has the code been profiled?

Functions

Are function parameters explicitly verified in the code?
This check is encouraged for functions where you don't control the whole range of values that are sent to the function. This isn't the case for helper functions, for instance. Each function should check its parameter for minimum and maximum possible values. Each pointer or reference should be checked to see if it is null. An error or an exception should occur if a parameter is invalid.

Are arrays explicitly checked for out-of-bound indexes?
Make sure an error message is displayed if an index is out-of-bound.

Are functions returning references to objects declared on the stack?
Don't return references to objects declared on the stack, return references to objects created on the heap.

Are variables initialized before they are used?
Make sure there are no code paths where variables are used prior to being initialized. If an object is used by more than one thread, make sure the object is not in use by another thread when you destroy it. If an object is created by doing a function call, make sure the object was created before using it.

Does the code re-write functionality that could be achieved by using an existing API?
Don't reinvent the wheel. New code should use existing functionality as much as possible. Don't rewrite source code that already exists in the project. Code that is replicated in more than one function should be put in a helper function for easier maintenance.

Bug Fixes

Does a fix made to a function change the behavior of caller functions?
Sometimes code expects a function to behave incorrectly. Fixing the function can, in some cases, break the caller. If this happens, either fix the code that depends on the function, or add a comment explaining why the code can't be changed.

Does the bug fix correct all the occurrences of the bug?
If the code you're reviewing is fixing a bug, make sure it fixes all the occurrences of the bug.

Math

Is the code doing signed/unsigned conversions?
Check all signed to unsigned conversions: Can sign completion cause problems? Check all unsigned to signed conversions: Can overflow occur? Test with Minimum and Maximum possible values.

Interesting Code Review "Facts"

2007-10-25T16:45:00.001+06:00

The benefit of code reviews is undeniable.

Yet, code reviews don't happen in most software development organizations. And for good reason. The way code reviews are typically handled uses an enormous amount of people and time resources. Even with system quality improvements developers may not feel the effort is worth the cost.

It turns out you don't need a high overhead code review process to get results. At one company I worked at I created a very low overhead automated code review system that enabled every line of code to be reviewed before it was checked-in.

Here are some ideas of how code reviews can be made practical in your organization.

Interesting Code Review "Facts"

My initial impression of code reviews is that they were heavy and bloated and a waste of time. I was wrong on all counts. Here are some interesting facts I found in the research:

Using two inspectors is as effective as using four or more.
Using an asyncronous process is as effective as a meeting based process for code reviews. For design reviews a meeting based approach may be more effective.
One review session is as effective as multiple inspection sessions.
Scenario or perspective based reviews were more effective than add-hoc and check-list based reviews.
Inspections are effective.
Inspecting upstream process like requirements and designs is very effective.

The implication is that the complexity and overhead of Fagan like code inspections are not needed and a semi-automated method will yield improved system quality. Requirements and HLDs seem to benefit from a more structured inspection process, which makes a certain amount of sense.

Code Review Standard

This is the list of some policies I would use to create a code review standard for my organization. Take what's here, read the review on code research, and figure out what will work best for your organization.

The key point to keep in mind is that the heavy weight nature of code reviews is not true. You can create a code review system for your group that is light enough that you can review every change in your entire system.

Every Line of Code Must Be Reviewed Before it is Checked-In

Do not allow code to be checked-in unless it has been reviewed, fixed, and rereviewed. If you can't do this then your review process isn't fast or light enough. It can be done.

Reviewing code after it has checked-in is next to useless as everyone is exposed to the unreviewed code.

Code Must Be Integrated, Compiled, Unit Tested, and System Tested Before Review

Spending time on code that is just going to change or doesn't work is a massive waste of time. The entrance requirements for a code review are:

Code should compile without errors or warnings (according to coding standard).
Code should be already be integrated with its parent branch.
Code should be fully unit tested.
Code should already pass the system tests where possible.

Develop Perspective Based Reviews

For the issues that are important in your software consider developing a Perspective Review for each issue. Perhaps special hotspots for you are internationalization, memory corruption, memory usage, threads, semaphores, etc. An example can be found in Semaphore Perspective Code Review.

You can then use the perspectives to assign roles to review team members.

Use Meetingless Asyncronous Reviews

You don't need to hold a big meeting for a review. Everyone can review the code when they can find time. Simpy have a done-by date when the review must be completed.

Everyone on the review must review the code. If a person can't perform the review then the team needs to elect someone else to perform a similar role in the review.

Meetingless aysncronous reviews are fast and light, yet they are still effective. With the right tool support you can easily review every line of code in your system.

Use Between 2 and 5 Relevant Reviewers

Too many reviewers wastes everyones time. Keep the number of reviewers small and relevant to the code being reviewed.

Assign Reviewers Roles and Perspectives

It's almost impossible to review a lot of different issues in a lot of code. People get tired and they stop noticings things.

The way around the getting tired issue is to use perspective reviews. Create a perspective for each important issue category your are concerned about. Assign the perspectives to people on the review team. Because they are only reviewing for issues in their perspective they will do a better job because they can stay more concentrated. This doesn't mean they can't find other issues as well, but they responsible for their perspective.

For example, if using semaphores correctly is important in your software and the code has semaphores, then assign someone the role of reviewing semaphore usage. An example can be found in Semaphore Perspective Code Review.

All Review Communication Should Go to the Review List and be Logged

Part of the benefit of a review is that people learn about the system being reviewed. This learning feature is facilitated by broadcasting email communication between the review team and saving all communication so it can be read by other people later.

Do Not Redesign in the Review

Make a note and schedule design issues for for a later time.

Developers always think they can do stuff better. Take these issues off line unless the issue is that requirements are not being met. Requirements not being met is not the same as you could have done it better.

Do Not Cover Coding Standards Violations in the Review.

Send violations via email or in person.

Talking about violations only gets everyone angry and is a waste of time.

Code Is Rereviewed Until it Passes

Code isn't reviewed once and then forgetten. Any changes made have to be rereviewed. If you think this is too slow then your process isn't light enough.

No reviewing all changes makes the process useless as people will just ignore suggestions or introduce new bugs in any changes.

All Issues Must be Fixed, Marked as Not an Issue, or Marked as Bug

Any issue brought up to a developer must be handled. A developer just can't ignore issues because they think it's stupid. Every issue must:

Fixed.
Marked as Not an Issue. If the developer and the reviewer can't decide between themselves if an issue should be fixed or not, then the review team gets to decide. If there is only one reviewer then bring a manager in or another team memember.

Automate Your Code Review System

You can make your process light enough by building it into your build system. If your process isn't light enough work on until it is.

Review All Code on Private Branch Before a Merge

Code developed on a private branch doesn't need to reviewed during development. But before the code is merged into a parent branch all code changes must go through the complete review process. For this reason, development of a large scale feature, may still want to perform reviews on the private branch because that can speed up the merge process.

Of course, try not to have branches separate from the mainline, but for large features that take a long time to develop you will often need separate branches.

Review the Right Scope of Changes

You don't have to review every line of code in every module that has changed. Certainly if a module is new it must be completely reviewed. Other than that you may be able to just review the changed code. Though just reviewing changed code isn't always possible. If you are performing a semaphore perspective review, for example, then you will need to go look at the code within in the scope of the sempahore as well.

Stick to Reviewable Issues

Develop your list of what issues can be reviewed and how they are to be reviewed. Usually this is in the form of check lists and perspective reviews. Don't allow reviews on other items without changing what can be reviewed. Otherwise people spend endless time on off-topic arguments.

Review Team Reponsible for Deciding Issues

If there is a conflict on any part of the review then the review team is responsible for handling it. That's the only way the review process will be light enough to work.

Keep it Cool

Nobody is perfect. The attitude of the review should never be personal, it should always be professional, with the goal of improving the system and the people building the system. Keep your tempers.

Don't blame people for bugs. Work together to make things better. No finger pointing! Not ever!

Meetingless reviews can help keep the anger down, but it can make it worse too. When people are in the same room anger can ramp up really quick. And we know in email it's very easy to say something that can be take wrong. Raise the awareness of these issues in your team.

A good rule is to Never Assume An Attack. If you find yourself getting angry, assume it's a misunderstanding, not an attack.

No Managers

Unless a manager has something to add to the reviews then they shouldn't be involved. Issues should be decided by the review team. Managers always have to run to a different meeting, they don't have time slots open for meetings, and they generally don't add technical input. So you don't need managers as part of the review process.

If a Bug Was Not Caught in a Review Figure Out Why

If a bug happens after a review then track down why each bug wasn't found and then change your development process somehow to try and prevent that bug in the future.

This is not always possible as running full tests are often impossible, but it should be mostly possible.

I would create a bug for each bug to track down why it wasn't caught. Because this issue is more serious than just the review. It means the unit test, the system test, and the review did not work.

Review Upstream Documents Too

Reviewing product requirement documents, specs, standards, etc can provide excellent return on value. Make sure those products are reviewed as well.

Feed Leasons Learned Into the Team and Documentation

If issues come up during the review that everyone in the team would benefit from, then have a way to make wisdom public.

I would recommend a development wiki where you can write documentation on anything useful that people come up with.

Plug Reviews into Your Source Code Control System

I have done this through change check-in comments. Each change has to be reviewed before it is checked-in. The submit comment must contain a review ID that points to some document containing the review status for the change that is about to be submitted. The code is prevented from being submitted without a valid passed review. If you are able to automate your code review system all this works quite quickly and painlessly.

Perspective Based Reviews

Before my reseach into code reviews I had never before heard about perspective based reviews . Perspective based reviews are done from the point-of-view of various project stakeholders. This is as apposed to everyone doing an add hoc or checklist based review. A perspective would be a user, requirements person, hardware interface, exception handling, mutex usage, memory usage, etc. The thought is they are more effective because reviewers are concentrating on a particular issue instead of trying to review everything. Do one thing well i guess.

Reviews are driven by scenarios. A scenario tells the insepector how to go about reading the documentation from particular perspective and what to look for. Clearly there's a lot to the scenarios.

Perhaps people could be assigned in various review roles. Or maybe some people can perform reviews only from a certain perspective.

Deciding If Code Reviews Work

How do you know if code reviews are working for you? Look for

Increased in test execution rate. The tests suites runs through its test suite. Unstable software can't do this.
Increased pass rate.
Reduction of critical bugs in QA.
Reduction of field issues.
Subjective improvements in quality.

Try to measure the issues to verify if code reviews are working for you.

Are Code Reviews Necessary With Pair Programming?

An issue that comes up is the relationship between code reviews and pair programming . Do you still need code reviews if you pair program?

If you don't pair program then you definitely should perform code reviews. That one is easy. Unit tests and system tests simply aren't good enough to replace code reviews.

After that it depends.

It depends on the product you are developing, it's importance, it's complexity, and how critical it is that there be no errors.

Pair programming is an excellent form of active code review, but there are many products where I don't think two eyes are enough. Some systems are complex enough, some domains are complex enough, and some conseuqneces are severe enough that I want more eyeballs on them before the code is let loose in a real code running system.

When pair programming is used you could decide what code should be reviewed by subsystem or by the type of change involved.

For example, code in a key algorithm may need to be reviewed by the impacted parties. Perhaps a drive change needs to be reviewed. Perhaps when a piece of code is written new or completely rewritten, it should be reviewed. Perhaps if semaphores are added to code that would trigger a review because it changes the system a great deal.

Your mileage may vary of course.

Charecteristics of commercial software

2007-10-25T16:36:00.000+06:00

Commercial Softwares - A term with whom most of the software professional, including me, are familiar with. There are thousands of different commercial software in different areas; even though all of them share some common properties such as: built by many, expandable, maintainable, understandable, and stable.

Lets see what are those:

Built by many: Software that is built by a team inherently means that no single person has firsthand knowledge of all of the code. It also means that good communication among the team members is critically important to the software's success. Communication has to start at the beginning; everyone on the team must share an understanding of what exactly is being built, for whom, and when it is needed. By understanding the customers and their requirements, you can always go back and ask yourself, "Is this feature I'm adding really necessary?" Understanding both the business and product requirements can help you avoid the dreaded feature creep or increasing scope that often delays products. Communication has to continue throughout the process: conveying interface designs so that integration among components runs smoothly; accurately and completely documenting your code; and conveying new member functions and their purpose to the Software Quality Assurance (SQA) and Documentation groups.
Expandable: You must be able to add new features quickly and extend existing features in commercial software. These requests often seem to come when an influential customer finds that they need just one more thing to solve their problem. Even worse is when a limitation is discovered only after the product is released. Whether or not code can be easily expanded to accommodate these requests is often a function of the design. While it may be as easy as adding a new member function, significant new features require that the design be extended. Put simply, you have to think ahead when designing and writing code. Just implementing to a specification, with no thought to future expansion or maintainability, makes future changes much more difficult. A further complication is that most software won't allow features to be deprecated once the product is in use. You can't simply remove a class that was ill conceived, as it is certain that if you do so, you'll find a whole host of customers using it. Backward compatibility is often a key design constraint.
Maintainable: No matter how many unit tests are written, automated tests are run, or functional tests are executed, it is inevitable that bugs will be found after the product has been released. For commercial software, the goal of all of the rigorous testing and preparation is to ensure that any post-release bugs have minor consequences to the product. What becomes crucial is that these bugs be easily and quickly corrected for the next release. It is also likely that the person who implemented a particular component won't be the person responsible for fixing the bug, either because enough time has passed that he has been assigned to a different project, or there are designated engineers responsible for support and maintenance. Given these constraints, maintainability must be designed into the software. There has to be an emphasis on solid design practices and clarity in coding styles, so that the software can be efficiently maintained without further complicating it.
Understandable: Commercial software often includes visible software interfaces. If you are building an embedded system library, it needs to be understandable to the application engineers within your company. If you are building a software library, the interface you present must be easily understood by your customers so that they can use it to build their own applications. This doesn't just mean that naming conventions must make sense, but more importantly that your design and your use of language elements, like templates, are clear and appropriate.
Stable: Commercial software must be stable; that is, it must be able to run for extended periods of time without crashing, leaking memory, or having unexplained anomalies.

Me, in Cherapunji

2007-10-23T18:49:00.001+06:00

Me, in Cherapunji
Originally uploaded by Happy-Man

This is a observation point at Cherapunji, India. We had a great expectation about the seven-sister fall that we read on internet before visiting India. The local guide told us in rainy season the fall becomes large enough and looks great.

Hard luck !! We went in winter :(

2007-10-23T18:40:00.001+06:00

Ajax : A simple and basic example with callback function

2007-08-21T11:01:00.000+06:00

The function takes the request url and a function as parameter. The function as parameter is used as call back function whe ajax status is ready.

Feel free to use the code.

function sendRequest(req,fn)
{
// alert(req);
var xmlHttp;
try
{
// Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}
catch (e)
{
// Internet Explorer
try
{
xmlHttp=new ActiveXObject("Msxml2.XMLHTTP");
}
catch (e)
{
try
{
xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");
}
catch (e)
{
alert("Your browser does not support AJAX!");
return false;
}
}
}
xmlHttp.onreadystatechange=function()
{
if(xmlHttp.readyState==4)
{
fn(xmlHttp.responseText);
}
}
xmlHttp.open("GET",req,true);
xmlHttp.send(null);
}

Use it as:

function OnSearch(msg)
{
alert(msg);
}
sendRequest((url),OnSearch);

PostgreSQL Cheat Sheet

2007-08-21T10:49:00.000+06:00

CREATE DATABASE

CREATE DATABASE dbName;

CREATE TABLE (with auto numbering integer id)

CREATE TABLE tableName (
id serial PRIMARY KEY,
name varchar(50) UNIQUE NOT NULL,
dateCreated timestamp DEFAULT current_timestamp
);

Add a primary key

ALTER TABLE tableName ADD PRIMARY KEY (id);

Create an INDEX

CREATE UNIQUE INDEX indexName ON tableName (columnNames);

Backup a database (command line)

pg_dump dbName > dbName.sql

Backup all databases (command line)

pg_dumpall > pgbackup.sql

Run a SQL script (command line)

psql -f script.sql databaseName

Search using a regular expression

SELECT column FROM table WHERE column ~ 'foo.*';

The first N records

SELECT columns FROM table LIMIT 10;

Pagination

SELECT cols FROM table LIMIT 10 OFFSET 30;

Prepared Statements

PREPARE preparedInsert (int, varchar) AS
INSERT INTO tableName (intColumn, charColumn) VALUES ($1, $2);
EXECUTE preparedInsert (1,'a');
EXECUTE preparedInsert (2,'b');
DEALLOCATE preparedInsert;

Create a Function

CREATE OR REPLACE FUNCTION month (timestamp) RETURNS integer
AS 'SELECT date_part(''month'', $1)::integer;'
LANGUAGE 'sql';

Table Maintenance

VACUUM ANALYZE table;

Reindex a database, table or index

REINDEX DATABASE dbName;

Show query plan

EXPLAIN SELECT * FROM table;

Import from a file

COPY destTable FROM '/tmp/somefile';

Show all runtime parameters

SHOW ALL;

Grant all permissions to a user

GRANT ALL PRIVILEGES ON table TO username;

Perform a transaction

BEGIN TRANSACTION
UPDATE accounts SET balance += 50 WHERE id = 1;
COMMIT;

Basic SQL

Get all columns and rows from a table

SELECT * FROM table;

Add a new row

INSERT INTO table (column1,column2)
VALUES (1, 'one');

Update a row

UPDATE table SET foo = 'bar' WHERE id = 1;

Delete a row

DELETE FROM table WHERE id = 1;

Prints in under two pages. Questions, comments, criticism, or requests can be directed Here

More Cheat Sheets Here.

Copyright © 2005 Foundeo Inc. (http://foundeo.com/) / Peter Freitag (http://www.petefreitag.com/), All Rights Reserved.
This document may be printed freely as long as this notice stays intact.

Apache Cheat Sheet

2007-08-21T10:43:00.000+06:00

Apache Cheat Sheet

Setup a Virtual Domain

NameVirtualHost *

DocumentRoot /web/example.com/www
ServerName www.example.com
ServerAlias example.com
CustomLog /web/example.com/logs/access.log combined
ErrorLog /web/example.com/logs/error.log

Include another conf file

Include /etc/apache/virtual-hosts/*.conf

Hide apache version info

ServerSignature Off
ServerTokens Prod

Custom 404 Error message

ErrorDocument 404 /404.html

Create a virtual directory (mod_alias)

Alias /common /web/common

Perminant redirect (mod_alias)

Redirect permanent /old http://example.com/new

Create a cgi-bin

ScriptAlias /cgi-bin/ /web/cgi-bin/

Process .cgi scripts

AddHandler cgi-script .cgi

Add a directory index

DirectoryIndex index.cfm index.cfm

Turn off directory browsing

Options -Indexes

Turn on directory browsing


Options +Indexes

Create a new user for basic auth (command line)

htpasswd -c /etc/apacheusers

Apache basic authentication

AuthName "Authentication Required"
AuthType Basic
AuthUserFile /etc/apacheusers
Require valid-user

Only allow access from a specific IP

Order Deny,Allow
Deny from all
Allow from 127.0.0.1

Only allow access from your subnet

Order Deny,Allow
Deny from all
Allow from 176.16.0.0/16

mod_rewrite

Turn on the rewrite engine

RewriteEngine On

Redirect /news/123 to /news.cfm?id=123

RewriteRule ^/news/([0-9]+)$ /news.cfm?id=$1 [PT,L]

Redirect www.example.com to example.com

RewriteCond %{HTTP_HOST} ^www\.example\.com$ [NC]
RewriteRule ^(.*)$ http://example.com$1 [R=301,L]

This is a work in progress - Questions, comments, criticism, or requests can be directed Here

More Cheat Sheets Here.

Copyright © 2005 Peter Freitag (http://www.petefreitag.com/), All Rights Reserved.
This document may be printed freely as long as this notice stays intact.

A typical source file header

2007-08-14T17:38:00.000+06:00

//-----------------------------------------------------------------
/**

Author : Shaikh Sonny Aman
eMail : mailtoaman@gmail.com
Date : 14 AUG 2007
License : GNU Public License

App : CommentCount
Module :
File : CommentCounter.cpp
Purpose : This application will count the comments in source files
and print a metric result.

Known Issues:

History
^^^^^^^
Author Date Modification
----------------------------------------------------------------------
AMAN 14 AUG 2007 Initial Creattion

Use versioning… an easy solution --- TortoiseCVS.

2007-08-14T14:49:00.000+06:00

Perhaps, most of us have been fallen under situation when we wished if we could get a earlier version of our work!Hence rises the importance of versioning and using some versioning tools like SourceSafe, Source Off Site and of course the CVS.

Most probably, CVS is the most widely used version controlling tool. Though undoubtedly, it has some very good features, but unfortunately as well, it is a command line tool; furthermore it is mainly for Unix/Linux. For this, we face little bit problems using this excellent tool.

Now, TortoiseCVS is an CVS front end built for Windows® platform and the installer also installs CVSNT, a cvs tool for Windows®.

It is the easiest CVS tool I have ever used. You can right click on a folder or a document and add it to CVS. You can commit, update, view history, view change graph, diff and get any version by simply right click.

Here are some screenshots:

Parse command line and some utility functions

2007-08-09T14:46:00.000+06:00

I was assigned to write a dictionary module for a huge MFC project. The library as well as the executable has to be fully compliance with standard c++.

Now, I have to write a parser. I know I don't really have to write one, as there is already many out in the net. Why to make the wheel again ? Well known answer -- as I can :)

//Declare
wstring CLGetKeyValue(wstring cl ,wstring key, wstring::size_type pos=0);
void ParseCommandLine(wstring cl,wstring::size_type pos=0);

std::map <wstring,wstring> tb;

//this is for parsing

void ParseCommandLine(wstring cl,wstring::size_type pos)

{

wstring::size_type p1 = cl.find(L"-",pos);

if((int)p1 < style="">

return;

wstring::size_type p2 = cl.find(L" -",p1+1);

if((int)p2 < style="">

p2 = cl.length();

wstring pair = cl.substr(p1,(p2-p1));

int mid = (int)pair.find(L" ");

tb.insert(make_pair(pair.substr(1,mid-1),pair.substr(mid+1,pair.length()))) ;

ParseCommandLine(cl,p2);

}

//This checks the presence of a key

inline int CLHasKey(wstring cl,wstring key)

{

if((int)cl.find(L"-"+key+L" ") < style="">

return 0;

return 1;

}

//It returns the key value, assumed that the key is present

wstring CLGetKeyValue(wstring cl, wstring key, wstring::size_type pos)

{

//should be checked CLHasKey(cl,key);

wstring::size_type p1 = cl.find(L"-",pos);

if((int)p1 < style="">

return L"";

wstring::size_type p2 = cl.find(L" -",p1+1);

if((int)p2 < style="">

p2 = cl.length();

wstring pair = cl.substr(p1,(p2-p1));

int mid = (int)pair.find(L" ");

if( key.compare(pair.substr(1,mid-1)) ==0 )

{

return pair.substr(mid+1,pair.length());

}

return CLGetKeyValue(cl,key,p2);

}

Why message maps, How message maps

2007-08-08T18:03:00.000+06:00

( The article is taken from Kanitkar's book)

//comserver visitors ... :D )

Instead of using message maps we can think of using virtual functions to convert a message into a call to an appropriate handler. To understand how virtual functions can be used, look at the following code segment:

Class CFrameWnd

{

virtual void OnPaint(){}

};

Class myframe : public CFrameWnd

{

Myframe()

{

Create(0,”Draw”);

}

Void OnPaint(){}

};

class myapp : public CWinApp

{

public:

BOOL InitInstance()

{

Myframe *p;

p = new myframe;

m_pMainWnd = p;

p->ShowWindow(SW_SHOWMAXIMIZED);

return TRUE;

}

};

myapp a;

Here, myapp is the application class and a is the global application object. myframe is the frame window class. The compiler creates a table called VTABLE for each class that contains virtual functions and for the classes derived from it. The compiler places the address of the virtual functions for the particular class in the VTRABLE. If you don’t redefine a function that was declared virtual in the base class, the compiler uses the address of the base class version in the derived class’s VTABLE. When objects of the base class or derived class are created the compiler secretly places a pointer called vpointer (abbreviated as vptr) in the object. This pointer points to the class’s VTABLE.

The vptr is placed at the beginning of the object and is initialized to point to the starting address of its class’s VTABLE. This initialization is done in the constructor. All of this – setting up the VTABLE for each class, initializing the vptr, inserting the code for the virtual function call – all happens automatically. The VTABLEs for the two classes CFrameWnd and myframe are shown in the following figure:

VTABLE of CFrameWnd		VTABLE of myframe
&CFrameWnd::OnPaint		&myframe::OnPaint

In the 16-bit version of MFC, the MFC window classes were registered with AfxWndProc() as the message handler. In this function all the messages used to get handled. Since the 32-bit version of MFC, instead of AfxWndProc () the MFC window classes are registered with DefWindowProc () as a window procedure. Even now all the messages are ultimately routed to AfxWndProc () from where they are dispatched to various CWnd-derived objects. Why all messages still end up in AfxWndProc() has something to do with MFC’s message hook mechanism

Had a virtual function been used for converting a message into a call to the appropriate handler, the window procedure would have looked like this:

CFrameWnd *p;

p = AfxGetApp()->m_pMainWnd;

p->OnPaint();

Here, AfxGetApp () fetches the address of the global application object (created from myapp). m_pMainWnd is a public data member of the CWinApp class. This data member contains the address of the myframe object assuming that the window is built using the myframe class. In the statement,

p = AfxGetApp()->m_pMainWnd

we are storing the address of a derived class object in a pointer to the base class object. When we call the OnPaint () it must be determined whether the OnPaint () handler CFrameWnd class or one in the myframe class should get called. To determine this, contents of p issued. p contains address of the myframe object. First two bytes starting at this address contain the vptr. The vptr points to the address of the VTABLE belonging to myframe class. From this VTABLE, the address of myframe::OnPaint() is obtained and the control is transferred to this address. Thus, it is the derived class’s (myframe’s) OnPaint() which gets called. Had OnPaint() not been declared as virtual in CFrameWnd class then through

p->OnPaint();

the CFrameWnd::OnPaint () would have been called.

This in effect means that for every possible message that CFrameWnd object is going to receive there must be a virtual function in it. Otherwise we would never be able to override it in a class derived from CFrameWnd. This would lead to a huge virtual table. Message maps are a MFC’s way avoiding this lengthy virtual table.

Another difficulty with virtual tables arises in case of user-defined messges. Suppose we write a handler, say fun() in the myframe class. And now to call it if we say p->fun(), an error will result. This is because fun() has not been defined as virtual in the CFrameWnd class. The difficulty is we do not have the source code of the CFrameWnd class hence cannot make the virtual declaration. In effect it means that we cannot tackle user-defined messages through the mechanism of virtual functions.

Let’s now understand the mechanism of message maps. Any class derived from CCmdTarget can contain a message map. What MFC does internally to implement a message map hidden behind some rather complex macros. To understand the message mechanism consider the following small code snippet:

class myframe:public CFrameWnd

{

Void OnPaint(){}

DECLARE_MESSAGE_MAP()

};

BEGIN_MESSAGE_MAP()

ON_WM_PAINT()

END_MESSAGE_MAP()

The macros DECLARE_MESSAGE_MAP(),BEGIN_MESSAGE_MAP() AND END_MESSAGE_MAP() have been defined in the file ‘afxwin.h’. During preprocessing the DECLARE_MESSAGE_MAP macro adds three members to the class declaration:

(a) a private array of structures called _messageEntries[]. Each element of this array is a structure called AFX_MSGMAP_ENTRY. In addition to other elements, this structure contains a message id and a pointer to a function that should get called when a message with this id arrives.

(b) a structure called messageMap. This structure contains a pointer to class's _messageEntries[] aray and a pointer to base class/s messageMap structure.

( c) A virtual function called GetMessageMap () that returns messageMap structure's address.

Not that the _messageEntries[] arrray and the messageMap structure are static members of the class. This means there is one instance of them. The begin BEGIN_MESSAGE_MAP() macro contains the implementation of the GetMessageMap() function and the code to initialize the messageMap structure. The macros that appears between BEGIN_MESSAGE_MAP() and END_MESSAGE_MAP() fill in the _messageEntries[] array. Finally,END_MESSAGE_MAP() marks the end of the _messageEntries[] array with a NULL entry.

With this infrastructure in place let us now understand how a message passed to the application window gets converted into a call to the appropriate message handler.

Suppose a message, say WM_PAINT, gets posted in the message queue. This message would be retrieved by the GetMEssage() function and would be dispatched to the AfxWndProc() function by the DispatchMessage() function.

Inside the AfxWndProc() function, the framework retrieves the C++ object associated with the window handle using CWnd::FromHandlePermanent() function. AfxWndProc() then calls that object’s ( the one derived using FromHandlePermanent() ) WindowProc() function. The WindowProc() function gets the address of myframe’s messageMap structure.

As discussed earlier, this structure contains the address of _messageEntrioes[] array. The id of the message picked up from the message queue is now searched in this array. If the entry is found then the handler corresponding to it is immediately called (as you may recollect, the _messageEntries[] contains message ids and the names of their handlers).

If the message id is not found in the _messageEntries[] array of the mainframe class then the _messageEntries[] array of the myframe’s base class is searched.

But how can we reach the _messageEntries[] array of base class? This is achieved using the pointer to the base class’s messageMap structure, which is stored in myframe’s messageMap structure. If the base class does not have the handler for the message the framework ascends another level and consults base class’s base class, systematically working its way to the inheritance chain until it finds the message handler or it has reached the father of all classes. If it still cannot find the message handler then the framework passes the misusage to Windows for default processing.

The MFC’s message mapping mechanism amounts to an efficient way of connecting messages to message handlers without using virtual functions. In contrast to virtual tables the amount of memory used by message maps is proportional to the number of message entries it contains.

বিকালে বিপদ

2007-08-05T16:39:00.000+06:00

(পুরানো কাগজের মাঝে খুজে পেলাম। সাত বছর আগে লিখা )

রিক্সার ওপর বসে আছি। রিক্সা রাস্তার ওপর বসে আছে। আর রিক্সাচালক বসে আছে রিক্সার পেছনে। বসে বসে অসহায় চেইনটাকে ক্লান্তিহীন ভাবে নাড়াচ্ছে। যশোর এয়ারপোর্ট থেকে ক্যান্টনমেন্ট গেট পর্যন্ত এই নিয়ে তৃতীয়বার। ভেবে দেখলাম, আমি যতবারই কোন 'মহৎ' উদ্দেশ্যে বের হই, ততবারই কোন না কোনভাবে ধরা খাই। ভাগ্যের এই পরিহাস বড়ই নির্মম।

তাছাড়া আর কি'বা ব্যাখ্যা দিব, বলেন ? বিমান বাহিনীতে বৈমানিক হিসেবে কমিশন পাবার পর পোস্টিং হল যশোরে। ভেবেছিলাম উইকএন্ডে ঢাকায় গিয়ে রোশনীর সাথে ধুমসে ঘোরাঘুরি করব। কিন্তু প্রথম উইকএন্ডেই অনুমতি চেয়ে ব্যর্থ হলাম। কিন্তু, "লাভ কে লিয়ে কুচভী করেগা" মুভিটাও সেদিন দেখলাম; তাই কাউকে না বলে চুপি চুপি চলে আসি ঢাকা এবং ফিরে আসামত্রই ধরা খাই যথারীতি। ফলস্বরূপ, আগামী দুই মাস "নো উইকএন্ড"।

কিন্ত, সমস্য সেটা না। বর্তমান সমস্যা হল রোশনী এখন যশোরে। তাও মাত্র চারদিনের জন্য। ঠিক রবি থেকে বুধ - যে কয়দিন সারাদিন থাকে ফ্লাইং আর বিকেলে পি.টি.। দেখা করার সুযোগ কোথায়, বলুন তো? এখন, আমি যদি এই চরম সংকটে পি.টি. ফাঁকি দিয়ে শহরে যাই, তবে কি আমাকে খুব বেশি দোষ দেয়া যায় ? এবং পরপর তিনদিনই যদি স্কোয়াড্রন লীডার আসাদ স্যার( আমার ফ্লাইং ইন্স্ট্রাক্টর ) আমাকে দেখে ফেলে, সেটাকেও তো খুব অস্বাভাবিক বলা যায় না তাই না? ? তাই আজ সকালে স্যার যখন তাঁর গম্ভীর মুখটাকে আরও গম্ভীর করে ঠান্ডা গলায় বল্লেন, "পি.টি. টাইমে যেন কাউকে শহরে না দেখি, ওকে ? আদারওয়াইজ, ইউ অল উইল হ্যাভ দ্য জোক"-- তখন ব্যাপারটাকে খুব স্বাভাবিক ভাবেই নেই। তাই আজ চতুর্থবারের মত পি.টি. টাইমে আমার শহরে আসাটা নিশ্চই আপনাদের কাছেও স্বাভাবিক লাগছে।

"নাইমা পড়েন, রিস্কা আর যাবেনানে।" ঊর্ধমুখি রিক্সাচালকের উদাসী কথায় আবার রাস্তায় ফিরে আসি।পকেট থেকে ভাড়া মিটিয়ে চুপচাপ আরেকটি রিক্সায় চাপি। চারটায় "ওয়েসিস"-এ পৌছানোর কথা। এখন বাজে তিনটা পন্চাশ।

আমার ঘড়িতে যখন কাঁটায় কাঁটায় চারটা এক, তখন আমি ওয়েসিস পোছাই। কিন্তু প্রতিদিনকার নির্দিষ্ট টেবিলটা (প্রায়) ফাঁকা। 'ও' নেই। নিজের মনে একটু হাসি। সামরিক কর্মকর্তা হিসেবে আমি বরাবরই প্রচন্ড পাঙ্চুয়াল, হাজার হোক রোশনী একজন 'সিভিলিয়ান'। তার দেরী হতেও পারে। দেরীর জন্য মনে মনে তাকে ক্ষমা করার স্বর্গীয় আনন্দে সময় গুনতে থাকি বসে বসে।

মিনিট দুই না যেতেই হাজির হল ও'। সশব্দে চেয়ার টেনে সামনে বসল। চেহারাটা গম্ভীর। অনুমান ভুল না হলে, তার অপূর্ব নাকটার দু'পাশের ত্বক সামান্য কুঁচকে থাকার কারনটা সম্ভবত 'কিছুটা' বিরক্তি। বুঝলাম, সামথিং ইজ রঙ।

"কেমন আছ, রোশনী?" মিষ্টি হাসি দেই ( অবশ্য রোদে পোড়া, ভাঁজ খাওয়া চেহারায় সেই হাসির মিষ্টতা নিয়ে কারও সন্দেহ জাগলে আমি দায়ী নই )।
"দেরী করলে কেন?", নির্লিপ্ত প্রশ্ন।
"মানে ?! বরং তুমিই তো.. না মানে রিক্সা... মানে ... দেখ মাত্র..." অবাক এবং ঝাঁঝাল অনুভূতির মিশ্রনটা এক নিমিষে ভ্যাবাচ্যাকায় রুপান্তরিত হয় দুইটা জিনিস খেয়াল হওয়ায়। ওভারকনফিডিন্সের জন্য আমি ঘড়িটাকে পাঁচ মিনিট স্লো রাখি, দ্বীতিয়ত, টেবিলের পাশে আগে থেকেই নিরীহভাবে পড়ে থাকা ব্যাগটা আমি চিনতে পেরেছি।
"তোমার দেরী দেখে আমি ফোন করি। তুমি বেরিয়ে এসেছ শুনে আবার ফিরে আসলাম। আচ্ছা, তুমি কবে একটু পাঙ্চুয়াল হবে, বলেতো ?", এটকু বলে সে তার লোভনীয় ঠোঁটের বাম কোনাটা সামান্য প্রসারিত করে। আসলে, বোধহয় এটা প্রসারন নয়, এটি একটি মিষ্টি হাসি। ডিফেন্স অফিসারদের স্ত্রীর মর্যাদা এক Rank সিনিয়র ধরা হয়, অদূর ভবিষ্যতে রোশনীর যোগ্যতা বোধহয় আমার থেকে অন্তত দুই rank ওপরেই হবে। ও'র জন্য গর্বে আমার বুকটা ফুলে ওঠে। কিন্তু পরক্ষনেই আবার চুপসে যায় তার কথায়----

"আজ কিন্তু আমি ছয়টা পর্যন্ত থাকব"।

সময় হিসেবে বিকেল ছয়টা হয়ত তেমন গুরুত্বপূর্ন নয়, তবে এটা হল সেই সময় যখন আসাদ স্যার ভাবীকে আনতে শহরে যায়। কাঁটায় কাঁটায় ছয়টা বাজতে রোশনী উঠল।
"চল, আমাকে একটু এগিয়ে দাও"
"দেখ , ইয়ে, আমার একটা সমস্যা আছে এখন"
দুই সেকেন্ড নিরব বিরতি।
"তাই নাকি, কি সমস্যা ?" গলার স্বরে যুগপত বরফের কাঠিন্য ও শীতলান।
"না, মানে, এক স্যার, মানে এখনই...." বুঝিনা, এত নার্ভাস হয়ে যাই কেন ওর সামনে। অথচ অফিসার হিসেবে আমি কিন্তু .... বুঝতেই পারছেন।
"আচ্ছা,থাক তাহলে। যখন এতই ভয় পাচ্ছ তুমি তাহলে এখানেই চুপচাপ বসে থাক, আমি চল্লাম। ও হ্যাঁ, এক ঘন্টার আগে বেরিও না কিন্তু।", একটা হান্ড্রেড পার্সপন্ট ভুবনমোহিনী হাসি উপহার দিয়ে বল্ল। গলার স্বরটাও যেন একটু বেশি মিষ্টিই লাগল। তার প্রতি কৃতজ্ঞতা ও ভালোলাগায় মনটা অাপ্লুত হত যাচ্ছিল প্রায়... হঠাৎ হোঁচট খেয়ে থেমে গেল। সুগার কোটেট কুইনিন ক্যাপসুল গিলতে গিয়ে মুখের ভেতরেই যেন ভেঙ্গে গেল। আমার সুপার সেনসিটিভ অনুভূতি জানান দিল মিষ্টি প্রলেপের ভেতর আছে কুইনিনের মত সূক্ষ অপমানের ছোঁয়া। আর, আপনারা এতক্ষনে নিশ্চই টের পেয়েছেন, আনার Ego এবং ব্যক্তিত্ব অত্যন্ত প্রবল।

চিন্তা করে বের করি, ওয়েসিস থেকে ঠিক বিশ পা এগোলেই ওর নানার বাড়ি যাবার গলি, যেখানে ও' এখন যাবে। ইনশাল্লাহ পার পেয়ে যাব।
"আশ্চর্য, তুমি যে কি বল না!! কিসের ভয়? চল", আত্মবিশ্বাসে ভরপুর দৃপ্ত উত্তর আমার।

বেরিয়ে আসি খোলা রাস্তার ধূলিময় মুক্ত বাতাসে। ওর সুকোমল হাতটা ধরে আবেগঘন দশ পা এগোনোর পর হঠাৎ আমার অভিজ্ঞ চোখের কোনে কি যেন ধরা পড়ে। তাকিয়ে দেখি দ্রুত অগ্রসারমান একটা কালচে ধূসর হেলমেট। T-37 জেট প্লেনের ডুয়াল ককপিটের পাশাপাশি আসনে আসাদ স্যারকে সবসময় ধূসর হলেমেট পরা অবস্থাতেই দেখি। চিনতে তাই একমুহুর্তও দেরী হলনা।

গত দু'বছেরে কঠোর প্রশিক্ষন আর পেশাগত শৃংখলার পুরস্কার হিসেবে গড়ে ওঠা সহজাত রিফ্লেক্স আমাদের অহংকার। ঝট করে ডান পায়ে মাটিতে ধাক্কা দিয়ে, বাম পা'টা ব্যালে ড্যান্সের ভঙ্গিমায় এগিয়ে দিয়ে নিমেষেই পাশের দোকানে শরীরটা ঢুকিয়ে দেই অপূর্ব দক্ষতায়। তবে সব মহান কর্মেরই ছোট্ট কোন ত্রুটি থাকা স্বাবাবিক, আমার এই সুনিপুন কর্মটাও এর ব্যতিক্রম নয়। আমার ডান পা'টা নিরাপদে মাটি স্পর্শ করার ঠিক আগের মুহুর্তে দরজার কোনে একটু বেধে যায়। যে কারনে হীট সীকার মিজাইলের মত নিক্ষিপ্ত হই কাউন্টারের ওপর। উপুড় হয়ে। এই সামান্য শব্দ সহ। এটা দেখে অভিভূত হয়ে কো আঁতেল সাহিত্যিক হয়ত বর্ননা দিতেন, "বিকট শব্দযোগে অমসৃন ভূপাতন"। কিন্তু আমি একজনা দ্বায়িত্ববার, বিশিষ্ট সামরিক কর্মকর্তা, সাহিত্যিক নই।

দোকানী তার চোখমুখ উজ্জল করে জিজ্ঞস করল, "কে মরিছে ভাই? ক্যাম্ভায়? খুব দুরুতো সার্ভিস লাগবে, বুঝতে পারিছি, কুন পরোব্লেম নাই, আমার কাছে আগর বাতি, কাফন, খাটিয়া...."। টুপি পরা ভদ্রলোকের থুতনীতে ঝুলন্ত মুঠো পরিমান দাড়ির শিল্পিত কাঁপন থেকে চোখ সরিয়ে চারপাশে চোখ বুলিয়ে বুঝতে পারি এটা "আখেরী বিদায়" জাতীয় দোকান।

দ্রুত সমালে উঠি আমার এই "আকস্মিক অনভিপ্রেত ভারসাম্যহীনতা জনিত বিহ্বলতা" থেকে। অভ্যস্ত হাতে বাঁকা হয়ে ঝুলে থাকা সানগ্লাসটা নাকের ওপর সোজা করে পুন:স্থাপন করি। দুহাত পকেটে পুরে দৃঢ় পদক্ষেপে বেরিয়ে আসি। রোশনীকে বোঝানোর জন্য স্মার্টলী বলা শুরু করি,
" একচুয়ালী, ব্যাপারটা হল, ইন্সটিঙ্কটিভ রিফ্লেক্স, তুমি তো জানই এজ এ ডিফেন্স অফিসার.... " মাঝ পথে থেমে যাই। সামনে রোশনী নেই। চলে গেল নাকি ?! বড় আশা নিয়ে ডান দিকে ফিরি, তার পথের দিকে। নেই। দিগুন আশা নিয়ে ধীরে ধীরে বাম দিকে তাকাই।

অতি পরিচিত কাঠামোটা দেখতে পাই। হাতের ইশারায় ডাকছে। আবেগের তীব্রতায় বুঝি একটা বিট মিস্ও করি। তবে প্রবল এই অনুভূতির উচ্ছাসকে ঠিক "ভালোলাগা" না বলে নিখাদ আতঙ্ক বলে সংজ্ঞায়িত করাই বোধহয় বেশি যুক্তিযুক্ত। আটকে থাকা দীর্ঘশ্বাসটা মুক্ত করে রওনা দেই বাইকে বসা আসাদ সারের দিকে।

Why calling SetWindowText in PreSubclassWindow does not work for a Dialog

2007-08-05T15:50:00.000+06:00

The OnInitDialog() follows the PreSubClassWindow(). So any initialization done in PreSubClassWindow() will be overwritten by the initializations that take place in OnInitDialog().

For this, say we called SetWindowText(L" My Dialog") in PreSubClassWindow(). After a while when OnInitDialog() is being processed, a call to SetWindowText is called with the Caption which can be set using the VS dialog editor.

Another point I would like to mention in this regard.

In normal window handling, we will have an OnCreate handler that is invoked just as the window is created. In normal MFC window handling, we have the PreCreateWindow virtual method which lets us change the CREATESTRUCT values, such as style parameters.

These are not accessible in dialogs. The reason is that the members of the subclass can be invoked only when the window is mapped into MFC, that is, its handler has been changed to be the AfxWnd handler. But dialog controls are created long before the subclassing, which takes place on the first DoDataExchange handler, which happens during the OnInitDialog processing. This is far too late.

PreSubclassWindow is an ideal place to make certain modifications, such as changing styles. This applies only to those styles which have an effect after the window has been created (many styles cannot be changed once the window is created. We can change the style bits( as like as calling SetWindowText as discussed above ), but the window itself is oblivious to these changes).

This is useful when the styles you want to change are not part of the styles presented by the dialog editor.

Responsive Java, Fast Java !

2007-06-14T18:11:00.000+06:00

জাভার বিরুদ্ধে সবচাইতে বড় অভিযোগ এটা রেসপন্স করতে দেরী করে, তাই ব্যাবহারকারীর কাছে এটা অনেক স্লো মনে হয়। অথচ, আমরা চাইলেই SwingUtils.invokeLater()ব্যাবহার করে আমাদের প্রোডাক্টকে আরও রেসপন্সিভ করতে পারি সহজেই।

jButton1.addActionListener(new java.awt.event.ActionListener()
{
public void actionPerformed(java.awt.event.ActionEvent evt)
{
SwingUtils.invokeLater
(
new Runnable()
{
JOptionPane.showMessageDialog(null, "You clicked me : ) ");
}
)
}
});

বেশি ভেজাল মনে হলে একটা Action ক্লাস বানিয়ে নিন, যেটাতে এটা ইমপ্লিমেন্টেড থাকবে।

Action class use করা খুবই মজার হতে পারে, তা নিয়ে আরেকদিন আলোচনা করব ইনশাল্লাহ

dos2unix all files in current directory using find -exec

2007-06-14T17:47:00.000+06:00

$find . -exec dos2unix {} \

Sometimes we copy some source code from windows to Linux and try to compile them. The result is often
very unexpected and likely to have no clue whats the wrong! Most of the time it is due to nothing but the file format difference in Linux and windows.

dos2unix comes from almost all Linux distributions. it converts an windows file to Linux format.

Change file name case to lower in linux

2007-06-14T17:05:00.000+06:00

$for i in *; do mv $i `echo $i | tr [:upper:] [:lower:]`; done

I am working on a project using MainSoft's MainWin. It converts and compiles vc6 projects in linux. MainWin provides a tool calls 'mwgenmake' which creates a makefile from the project file. Sometimes, it is required to have all the filename in lower case.

The code above is collected.