oOzone

C++ casts Demystified

2010-06-09T01:24:00.003+05:30

Hope the following code sample clarifies the differences between the various C++ casts. const_cast is left as a trivial case.


class V {public: virtual ~V(){}}; //Virtual Base Class

class G: virtual public V{}; //Common ancestor for base classes
class B1: public G{}; 

class B2{}; //Non-polymorphic class
class B3: public G{}; 

class D: public B1, public B2, public B3 {};

class I{ public: virtual ~I(){}}; //Independent, unrelated Class

int main(int argc, char* argv[])

{
 D d;
 D*  pdd=&d; 
 B1* pb1d=&d; //No casts needed

 B2* pb2d=&d; 
 B3* pb3d=&d; 
 V*  pvd=&d;

 //G*  pgd=&d; //Compile-error, ambiguous

 // I* pi1d=&d; //Cast needed. Compile error.
 I* pi1d=(I*)&d; //No compile error, but semantically wrong. Address gets assigned.

 //I* pi1d=static_cast<I*>(&d); //Compile error

 //Upcasting
 B1* pb1= dynamic_cast<B1*>(pdd); // = pb1d 

 B2* pb2= dynamic_cast<B2*>(pdd); // = pb2d

 B3* pb3= dynamic_cast<B3*>(pdd); // = pb3d

 G*  g1 = dynamic_cast<G*>(pdd); //No compile-error, but null because ambiguous

 G*  g2 = reinterpret_cast<G*>(pdd); //No compile-error, nothing

 //G*  g3 = static_cast<G*>(pdd); //Compile-error, but null because ambiguous
 
 //Downcasting
 D* pdd1 = dynamic_cast<D*>(pb1d); //downcast, B1 must be polymorphic

 //D* pdd = dynamic_cast<D*>(pb2d); //downcast, B2 not polymorphic. Compile error.
 G* g3= dynamic_cast<G*>(pvd); //ambiguous downcast, = null, compiles in C++ not in Comeau

// G* g4= static_cast<G*>(pvd); //ambiguous downcast, = null

 //Crosscasting
 I* pi= dynamic_cast<I*>(pdd); //pi will be null

 I* pi2= reinterpret_cast<I*>(pdd); //pi2 will be equal to pdd

 //I& ri= dynamic_cast<I&>(*pd); //throws an exception

 B3* pb31= dynamic_cast<B3*> (pb1d);



 return 0;
}

Rethink About Reuse

2010-05-29T01:27:00.002+05:30

Was listening to C++ Stylistics

1. Three pillars of OO
1. inheritance
2. encapsulation
3. polymorphism
1. overload
2. coercion
3. parametric
4. runtime inclusion
2. object oriented styles
1. prototype-based
2. object-based
3. dynamically typed
4. statically typed
3. object destruction policy
1. scope-nound
2. explicit
3. reference-based
4. GC

4. reuse is actually use!
5. use chairs to make a bed is reuse
6. using it again to sit is just use
7. inheritance-based
8. interface-based
9. challenge is to organize code
10. if you are not doing much, you become uncomfortable
11. "Adaptation"?
12. you cannot have virtual template functions

PAPPADOM Framework

2010-02-20T18:31:00.003+05:30

I have been working on a class of browser-based applications which don't require a server.
Calling it PAPPADOM = Portable Application Providing Persistence Atop DOM (Document Object Model)

PAPPADOM is a package consisting of
* Prototype Javascript framework
* Miscellaneous UI components - menubars, menu etc
* Persistence - save stuff

Advantages
* Portable - web-browsers supporting Javascript is all you need
* Open Data - data is stored within the HTML file and hence is accessible.

Examples:
Neptuner UBoat: http://neptuner.googlecode.com/files/demo_uboat_neptuner_0_20.zip
Memonaut: http://memonaut.googlecode.com

Just a fancy name...

Containers: Stick to basic types initially

2010-02-12T09:19:00.006+05:30

STL containers may impose a few requirements on your class (say for example, class Student) before they can contain them: like comparison operators, copy-constructors and a whole bunch of other things. This can be rather daunting (not to mention irritating) for the programmer, if his class is not containment-ready just yet and there is no example/documentation at hand: the error-messages are not friendly!

There might be quite a bit of boiler-plate code to add to the class Student before you can use STL containers to contain Student objects. Rather than getting your program’s core functionality up, you may find yourself just plugging in mundane code into your data-types, not to talk about all those strange-looking and mostly unreadable error-messages.

Example:

Say you want to make a grade-report for a group of students. It’s as simple as putting all your student records in an std::multimap, with Grade as key and iterating through the filled in multi-map (which groups the records according to the key).

class Student
{
string m_sName;

RollNumber m_xID;
Grade m_xGrade;
}

Tip 1: Work with pointers to your class. The use of the pointer also makes for better efficiency: no copies of your objects!
multimap<Grade, Student*> gaGradeReport;

Again depending on the contents of the class Grade, the compiler may squeal! It needs a comparison type LessThan before it can work…which brings me to Tip 2…

Tip 2: Use basic data-types for your key in associative containers like std::set, std::map etc. The easiest way to do it is to provide a conversion operator to a basic type for your key class.

multimap<short, Student*> gaGradeReport;

//After providing conversion to short
class Grade{... operator short() {...}}
Implement your program on these lines, get it working and then do the boiler-plate stuff.

Solution:
Here’s how you may do the grade-report task:

//Add the student info

for(..)//Iterate through the student objects one by one
(

 //Get the address of student record in pxStudent 
 gaGradeReport.insert(pair<short, Student*>(short(pxStudent->m_xGrade),pxStudent);

}

//Print the GradeReport multimap
for(..//each grade)
{
  for(..//each record in range)

  {//print the record}
}

Summary:
Work with basic data-types (pointers are basic data-types) for STL containers for more rapid development. Plug in the boiler-plate later.

Schedule Task, View Dependencies

2010-01-28T15:11:00.004+05:30

On Win2K+, schedule commands to run

## at "command"

Eg: at 07:45 "shutdown -s"

Shuts down the PC at 7:45 am.

You can view these tasks in Control Panel as well.

On *nix, view shared library dependencies of an executable.

## ldd

Make It Fast!

2010-01-17T12:56:00.003+05:30

Sharing a template for an easy to use make file system.

Self-maintaining: No need for manually adding files.
Quick-and-dirty: Get started fast!

Here goes:

SOURCE_FILES= $(wildcard *.cpp) ../../commando/sonar/Sonar.cpp
# Automatically gets the file-list from the directory!
# Add extra files from other dirs at the end if needed (Sonar.cpp above)

OBJS=$(patsubst %.cpp, %.o,$(SOURCE_FILES))
# Rule for specifying object file list

# The rest of this is standard make-file stuff

COMPILER=g++
CFLAGS= -W -g -O0 -fexceptions -finline-functions -D_THREAD_SAFE -fpack-struct=4
#Compiler options  
LIBS= -lboost_filesystem
#Libraries to link to

SEARCHDIRS = -I../inc -L../lib

#Include and library directories  

TARGET= ../../homebase/linux/nuboat
# Output file  

.PHONY:all
all: $(TARGET)

$(TARGET): $(OBJS)
$(COMPILER) $(CFLAGS) $(SEARCHDIRS) $(GLOBALS) $(OBJS) $(LIBS) -o $(TARGET)

%.o: %.cpp
$(COMPILER) $(CFLAGS) $(SEARCHDIRS) $(GLOBALS) -o $@ -c $<

.PHONY:clean
clean:
-rm -f $(OBJS) $(TARGET)

You can use this so long as you don't have source files floating around in the Makefile's directory, which should not be included in the build.

Neptuner Coding Guidelines

2009-12-13T01:12:00.000+05:30

==========================
NEPTUNER Coding Guidelines
- sonofdelphi
2009-12-13
2008-12-16
==========================

* To enable faster coding with an IDE
* To enable better debugging, no guessing what a variable is!

Variable naming
================

Variables are named as:


Scope Modifier
* Member variables start with m_
* Global variables start with g_
* Function Parameters start with "in_"
* Local variables don't have a scope modifier

Indirection Modifier
* Pointer variables start with p
* Reference variables start with r
* Other variables don't have an indirection modifier

Aggregation Modifier
* a - aggregates (arrays, vectors, lists etc)
* Plain variables don't have an aggregation modifier

Usage Modifier
* n - used for counting
* s - used as string
* c - character
* b - used as boolean
* f - used as a function. Deprecated though.
* e - enumeration types
* x - other structs, x = Complex = non-simple
* Other types (what are they?:-) don't have a usage modifier.

Indentation
=============
* Use a single indent for every {} block.

* { and } should be on new lines, at the same indentation level as the conditional.
Eg:
if(someCondition)
{
 statement1;
 statement2;
}

* Single line conditionals need not have {} marking.
  But make sure you indent the single statement.

Type naming
=============
* Follow TitleCasing for user-defined types - classes, structs, enums.
Eg:
class Student
{
 string m_sName;
 int    m_nMarks;
};

Function naming
================
* Functions should follow camelCase.
* The first word of a function should be a verb.
Eg: doSomeThing()

Pseudoclass functions
======================
* For C-style module functions, name as ModuleName_
Eg: Neptuner_addStuff

Hide details

Change log

r386 by sonofdelphi on Jan 26, 2010 Diff

dos2unix lineendings

Go to:

Double click a line to add a comment

Older revisions

r378 by sonofdelphi on Dec 20, 2009 Diff

r181 by sonofdelphi on Oct 10, 2009 Diff

r161 by sonofdelphi on Oct 09, 2009 Diff

All revisions of this file

File info

Size: 1790 bytes, 77 lines

View raw file

I Could Have Done It Too

2009-09-16T11:04:00.002+05:30

With application development, the question is not whether you could have done it; it's whether you did it at all.

Do you believe in your idea enough to invest the time and the effort it takes to do it?

Thomanujan Number - 1229

2009-06-29T20:58:00.007+05:30

INVALID POST
Thanks to Jeswin for pointing out bug in code.
:S :( Sheepish smile

Baseline Semantics

2009-05-27T13:17:00.003+05:30

The term Baseline can often be a source of confusion.

In my experience with Configuration Management and other tools (Microsoft Project etc), a baseline is anything “that can serve as a basis for comparison” – this may or may not be approved. SVN, in fact, skirts this baseline issue by defining the alternate terminology “tag” for the same thing!

I believe our problems stem from the–

1) Informal use of baseline as a verb, with the meaning ‘to approve’.

2) Lack of formalization of what type of baseline (and there are many kinds, refer below!) we refer to when we generically use the term baseline

References

Dictionary definition:

Noun: baseline

1. An imaginary line or standard by which things are measured or compared

(TJ: Other meanings for sake of completeness, also note “imaginary” J in 1)

2. The back line bounding each end of a tennis or handball court; when serving the server must not step over this line

3. The lines a baseball player must follow while running the bases

Wikipedia mentions:

Generally, a baseline may be a single work product, or set of work products that can be used as a logical basis for comparison. A baseline may also be established (whose work products meet certain criteria) as the basis for subsequent select activities. Such activities may be attributed with formal approval.

There are different kinds of baselines (from Wikipedia).

Functional Baseline: initial specifications established; contract, etc. Allocated Baseline: state of work products once requirements are approved

Developmental Baseline: state of work products amid development

Product Baseline: contains the releasable contents of the project

Others, based upon proprietary business practices

CMMi itself defines it multiply as (from CMMi-DEV 1.2 )

A baseline is a set of specifications or work products that has been formally reviewed and agreed on, that thereafter serves as the basis for further development or delivery, and that can be changed only through change control procedures. A baseline represents the assignment of an identifier to a configuration item or a collection of configuration items and associated entities. As a product evolves, several baselines may be used to control its development and testing.

For Systems Engineering

One common set of baselines includes the system-level requirements, system-element-level design requirements, and the product definition at the end of development/beginning of production. These are typically referred to as the “functional baseline,” “allocated baseline,” and “product baseline.”

For Software Engineering

A software baseline can be a set of requirements, design, source code files and the associated executable code, build files, and user documentation (associated entities) that have been assigned a unique identifier.

TJ:

In my opinion, attaching extra, “holy” meanings to an-already polymorphic word would not be appropriate. It would be a classic case of jargon-clash and would lead to inter-personal communication problems and possibly conflict!

It would also mean an incurrence of training (un-training) overhead and would be the proverbial seed for discontent in a new adopter.

INTEGRATE – 2008 - Changes done for 2K9

2009-01-01T21:51:00.000+05:30

0 error(s), 0 warning(s), 1 greeting(s)

Wish you a Happy New Year!

Log attached.

Recipe - Do Something To Each File In Directory

2008-12-14T11:18:00.001+05:30

This one is a real life-saver!

To do the same operation on each file, in Windows, you can use the for command.
for /F %i in ('dir *.dbg /s/b ') do @del %i

The above example deletes all *.dbg files under the current directory

Explanation
for /F %i ......... for each %i
in('dir *.dbg /s/b ') ..... in the list returned by the command. dir /s specifies a recursive search, /b causes it to to output just a list, without the file details
do @del %i ...... del %i is the command to delete the file. @ suppresses the display of the command

Recipe Syntax
for /F {%var} in ('{list-builder-command}') do {action-command}

Digital Peer

2008-11-11T10:07:00.000+05:30

Found a really cool and useful site while browsing around
http://www.digitalpeer.com/

There are tips, tutorials and articles here.

Hope it stays online!

On Reviews

2008-07-26T03:46:00.000+05:30

Reviews are like makeup; they can't make you beautiful, only less ugly.
- TJ

Perly Gates

2008-01-28T09:57:00.004+05:30

Tip 1:
Replacing string content with another string when both could contain backslashes.

Explanation:
Basically, you have to use \Q to escape. Otherwise, the contents of the strings (search & replace strings) will be interpreted as escape sequences.

Example:
The following is an extract from a script to get the relative path of a file with respect to a base-directory.

#!/usr/bin/perl

$BASE = "d:\source\";
print "Base : $BASE\n";

$TARGET = "d:\source\temp\test.txt";
print "Original : $TARGET\n";


$TARGET =~ s/\Q$BASE//;
#Replacing with null string
#syntax for replace:
#TargetString =~ is s/SearchString/ReplaceString/

print "Modified : $TARGET\n";
#Target becomes "temp\test.txt"

Tip 2:
Replace backslashes with forward slash.

If you do this the regular way, the regex you write will likely look like a squiggly drawing :) Something like /\/\\/ ;), which is a pain to read or debug.

#!/usr/bin/perl
# In Perl, any character can be used to delimit the regex! Here, using @ as separator
$STRING =~ s@\\@/@g;

Yeah, it's still ugly and we need to escape the backslash as \\, but that's they way it goes. Use this tip whenever you need to replace

Tip 3:
Get command line output into a variable

Here's a function to do this. Takes two parameters, the command-string to execute and a boolean option for showing the output on the display.

sub getCommandOutput
{
 my ($COMMAND, $DISPLAYOUTPUT) = @_;
 
 open(COMMAND_OUTPUT, "$COMMAND 2 >&1 |");
 my @OUTPUTLINES = <COMMAND_OUTPUT>;
 chomp(@OUTPUTLINES);
 close(COMMAND_OUTPUT);

 foreach $OUTPUTLINE(@OUTPUTLINES){

  print "\n$OUTPUTLINE" if $DISPLAYOUTPUT;
 }

 print("\n") if ($DISPLAYOUTPUT);
 return @OUTPUTLINES;

}

# TODO You may want to capture the error stream separately

The function returns the output of the command as an array which you can store into a variable.

Commentstipation

2007-12-13T23:58:00.000+05:30

When it comes to commenting the code, the cat gets the typing fingers of even creative and knowledgeable programmers. Often we are focused on just getting the code working (We'll comment later! The code has to work first!) and then we forget (what was that again? it's obvious, also time to go home...)!

Code should be self-explanatory and hence self-commenting, as far as possible. But this definitely does not mean that there should be no comments.

Good comments are hard to come by because of -
a) I-Am-A-Programmer-Not-A-Writer attitude
Well, you are a writer too.

b) "I don't know English that well" excuse
Grammatical errors are fine, spelling mistakes are also OK. Write in your native tongue and translate it, if need be. And, if what the code does is that tough to explain, then it's also the more reason to document it, it probably needs to be documented!

Remember the programming adage: Documentation is like sex, something is better than nothing! ;-) But, it must be said, inaccurate documentation is worse than no documentation. An addition to the adage is perhaps needed...having it the wrong way is probably worse than not having it at all! ;-)

TIPS
--------
* A comment should, at the very least, explain and focus on what is special in the block of code. A very good comment also explain why it is being done.

* The best comments explain the what and the why succinctly.

* How to comment
1. Ask yourself "What?"
2. Ask yourself "Why?"
3. Write what you would say to someone so that he could do what you have done. Use simple language. (This point intentionally abstruse, to serve as a memory-aid)
4. Review and edit what you have written, the best you can.

* Do not state the obvious! But also remember that what is obvious to you may not be obvious to another person. It's a thin line between advising and preaching.
Code like:
x=0; // Assigning the value 0 to the variable x
is a big no-no. Do not insult the intelligence of the reader. Plus, you'll have to scroll more while editing the code!

Coding Nirvana - Cryptic Mystic Droppings

2007-12-10T01:37:00.000+05:30

CRYPTIC MYSTIC DROPPINGS
FROM THE ELEVATED STATE
OF CODING NIRVANA

1. Code is just symbols.

2. Code needs a Thread of Life to achieve its Purpose.

3. It's all about the data.

4. It's all virtual. It can be faked but it doesn't really matter; it isn't really matter anyway.

More on each of these droppings (shit!) later.

Coding Nirvana - Four Noble Truths

2007-12-08T00:45:00.000+05:30

CRYPTIC MYSTIC DROPPINGS
FROM THE ELEVATED STATE
OF CODING NIRVANA

-----------------------------------------------------------
FOUR NOBLE TRUTHS
-----------------------------------------------------------
1. There is suffering
2. There is a cause of suffering. The cause is "Copy-paste"
3. There is the cessation of suffering - "Abstraction Of Commonality"
4. There is a way leading to the cessation of suffering — the Noble Eightfold Path

------------------------------------------------------------

"Copy-paste is the root cause of all programming suffering. Copy-paste is evil. The Eternal Conflict is between copy-paste and the Abstraction of Commonality."
- The Virtual Mystic

C Powershot - Pointers

2007-11-25T01:26:00.000+05:30

INTRO
---------
How should one interpret the following lines of C?

int *p;
"easy! p is an integer pointer!"

int **p;
"p is a pointer to an integer pointer" or perhaps you might say "p is a double pointer to an integer"

int ***p;
"hmm...er..ahem..why would anybody use such a thing! *@#$ ?"

POWERSHOTS - Interpreting a pointer declaration
----------------------------------------------------------------
The interpretations given i n the preceding section, even if somewhat correct, do not scale and could inhibit our ability to understand alien (written by other people) code. The words influence the way we think, so it's necessary that we choose the right abstractions. For example, if a pointer is 4 bytes, why shouldn't a double pointer be 8 bytes? :-) The right abstraction would not even allow us to stray down such lines of thought!

Here's a better way to interpret pointers.

SNN1.1 Pointers are variables which can hold the address of a memory location, usually the address of a variable.

Pointer Part
Consider the statement
int *p;
What the "*p;" portion of the statement says is only this : p is a pointer variable

Let's call the "* p" portion here the pointer part of the pointer declaration. It tells us this much p is a pointer and * operation can be applied on it.

CPS1.1 Whatever follows the * symbol is the pointer variable.

SNN1.2 Pointer variables in C have the * operation (fancier name: dereference) defined on them.

The deference operation gets the contents of the memory location held in the pointer. That is, if you dereference a pointer, you get what the pointer points to.

****

Type Part
Consider, again, the statement:
int *p;
What the "int " part means is this: when you apply the * operator on p, what you get will be interpreted as an integer. It can be used as an integer.

Let's call the "int " portion here the type part of the pointer declaration.

CPS1.2 Whatever remains in the statement after you blank out the pointer portion will be the type of what you get when you dereference the pointer.

FINGER-HIDING TECHNIQUE: Just hide the *p section with your finger, what remains is the type part. This finger-hiding technique can come in handy in other situations as well. It's nifty and mighty useful. It is an application of what I call the typedef principle, we will come to that in a later episode.

Summary:
Pointer declaration = pointer part + type part.
To reiterate, int *p means: p is a pointer, which will be dereferenced as "int"

EXAMPLES
---------------

EX1
int **p;
Pointer part: *p ====> p is a pointer
Type part: int * ====> when you dereference p, what you get should be interpreted as"int *".
You already know what int * means according to the power-shots! This has to be done repeatedly.

EX2
int *p[6][6];
Pointer part: *p =====> p is a pointer
Type part: int __ [6][6] ====> when you dereference p, what you get should be interpreted as "int [6][6]".
This is an array of integers with 6 rows and 6 columns. int

EX3
int (*p)(int i, int j);
Pointer part: *p =====> p is a pointer. The parentheses are required because otherwise due to precedence rule, the * would be associated with int and not p.
Type part: int __ (int i, int j) ==>when you dereference p, the type of data you'll get is "int (int i, int j) ".
This is an integer function which takes two parameters.
Yup, p is a function pointer. (But you do know better now, right? p is just a pointer, when you dereference it you will get something that can be used as a function)

EX4
int (*p(int a)) (int *b);
Pointer-part: *p ====> p is a pointer
Type-part: ( __ (int a)) ==> *p is a function.
So, p is a pointer to a function.
The remaining part is the type of the function.
Finally, p is a pointer to a function, which takes an integer, and returns a function which takes an int* parameter and returns an int!

Aside: Actually, the type part of the declaration is what is within the parentheses enclosing the pointer-part, but that would have confused you; also, this is not needed in the vast majority of cases. Parentheses always rule and dictate, as you should have guessed from the previous example as well!

You'd be much better off using typedefs for complex declarations like this one. But that does not mean that one should not know how exactly it is being interpreted. :-) More on typedefs later. For the time being, referring you to http://www.gotw.ca/gotw/046.htm where this particular example was taken from.

POSSIBLE GOTCHAS
-----------------------------------------
1. Function-pointers can, on some architectures, require more space than normal pointers. If code memory uses a different addressing size/scheme, for instance. Have not encountered this though.
2. Please use parentheses liberally(but judiciously!) inside declarations and the * operator while dereferencing the pointer. These are often skipped and lead to confusing (nah, 'misinterpretable') code.

Looking For A Function

2007-10-03T14:20:00.000+05:30

I am looking for a function
y = f(x1,x2...,xn)
such that given y and n, it would be possible to uniquely determine each of the x-factors.

1) It's OK for n to have an upper bound k, if k>=10 or so.
2) It is also essential that y be small

Any pointers would be welcome.

Code Is Prose

2007-09-26T11:53:00.000+05:30

Coding is a form of expression. We can draw many parallels between coding and writing; we write code, we are the authors of the code. When we code, we are actually translating our ideas and understandings into the the programming language. By that line of reasoning, a program is a user manual (or essay or poem, take your pick) that we write in a programming language.

Code is for reading
(and execution too)
-----------------------------
The computer doesn't care how we write the code as long as it works - no indentation is fine, cryptic lines are fine. We should try to get as close to natural language as possible. Do not go overboard though! Code like checkWhetherTheQueueIsEmpty() are no-no's though! Advise, but do not condescend.

Code is read many more times than it is written; code is WORM (Write Once Read Many). Debugging will be done on the code that you write more times than you write actual functionality into it. The code-maintainer will curse you less (he will curse anyway!) if the code you wrote, even if it is wrong, is easily understood. So code with meaning and gain some good karma!

But the clincher argument would be that we would have less of those pesky comments to write!

"Programs must be written for people to read, and only incidentally for machines to execute." - Abelson & Sussman, SICP

N COMMANDMENTS
----------------------------
* Avoid meaningless names.

* The meaning should not be ambiguous.

* Do not ever use a name that will not occur naturally to a person debugging the code.

* Do not abbreviate unnecessarily. Even if the abbreviation is logical to you, it might not be to another person.

* Vowel-swallowing is not desirable, nt_dsrbl at all.

* Be consistent. If you use underscores in your names to separate words, please don't use camel-case elsewhere and vice versa.
a) Capitalization -
b) Abbreviations - If you have to abbreviate (more often than not, this is a case of "I like to, hence I will") , then at least abbreviate consistently.

Recommended reading
-----------------------------
Literate programming
Writing Unmaintainable code (original)
Writing Unmaintainable code(expanded)

Saved By A Unit Test

2007-08-29T09:22:00.000+05:30

Consider a function called openCDTray( ) which ejects a CD from the drive.

This function should be operated only when the CD tray is closed. The function also has the following constraint(for effect). Attempting to open the tray when it is already open could result in the tray falling off and reattaching the tray is a cumbersome activity! :-)

The system maintains the status of the tray in a global variable/object called gCDStatus. openCDTray( ) should check the status and then only attempt to eject; otherwise all hell would break loose. But does the function implementation take care of this? Maybe the developer thought that nobody in their right mind would do such a thing and omitted the check. It's so obvious!

A unit test-case to check the response of the function in such a scenario could simply do the following:
1. Set gCDStatus to TRAY_IS_OPEN.
2. Call the function.
3. Check the result. The function should not have succeeded.

But our developers would never skip such basic checks! But even in such cases, unit-test can catch errors that could be missed in a cursory inspection of the code.
1. Typos in the assertion-check.
if ( gCDStatus = TRAY_IS_OPEN) throw ExceptionAlreadyOpen;
or if you consider that to be improbable too
if( gCDStatus = CD_EJECTED) throw ExceptionAlreadyOpen, where CD_EJECTED is a similar-looking, but different valid value for gCDStatus

2. The openCDTray( ) function might have been modified (copy-paste!) and the programmer inadvertently does something that causes a change of the gCDStatus value.

The unit-test also helps to find out whether the assertion-check has in fact been skipped. This becomes crucial during integration and has to be guaranteed before functional testing starts.
1. The user of the function may not be aware of all the preconditions and hence may not ensure all of them before calling the function.
2. The definition of another part of the system may have changed.

In the example of openCDTray( ) , we would be saved a trip to the CD repair shop by the unit-test!

Unit Test Scripts

2007-08-19T12:05:00.000+05:30

A unit-test function correspoding to each unit-test case broadly consists of the following sections.

1) Precondition Tweaking (Prologue)
Prepare the conditions necessary for the function to execute. Do this for all preconditions not mandated by the test-case; not supplying precondition(s) to see if the function fails may be the test-case.

2) Invocation (Test)
Call the function.

3) Post-condition Verification (Epilogue)
Check whether all the post-conditions have been enforced by the function. Check whether the result tallies with the expected result of the unit-test case.

4) Logging
This may be part of the unit-testing framework itself, if you are using one.

Link the test-function with the test-harness and the unit to be tested. Call these test-functions from a driver program to see how your unit copes!

Unit Test Environment

2007-08-17T12:04:00.000+05:30

A Unit Test Suite consists of code which verifies and validates the unit within the unit-testing environment. It consists of -
1) Test Script - Code which calls different functions of the unit under different conditions.
2) Test Harness - In order to achieve its functionality, the unit under test might need the help of other modules. Substitute all such external functions with dummy versions, stripped to the bare minimum.

The unit under test should be run under this unit-testing environment. For the unit of a complex, heterogeneous system, it is more practical and useful to have a unit-testing environment which is much simpler than the actual deployment environment.

Aside: It is tempting to make the unit-test environment "more real, just to see if it works too; anyway I am testing, so why not?". So if you do this, you will end up doing something that's neither unit- nor functional-testing, and you won't get the possible benefits of either!

More about test-scripts and test-harnesses later.

Limits Of Unit Diagnosis

2007-08-15T12:02:00.000+05:30

Unit-testing can uncover many kinds of deficiencies, gaps and faults. It is not the responsibility of a unit test to verify whether the function actually works or not, that is the domain of functionality-tests. Indeed, a unit may be successfully tested by the unit-test suite and still not work!

1) Inaccurate definitions - If the function succeeds even if some preconditions deemed necessary are not fulfilled, then probably the designer has made an error in the specification.
2) Unaddressed requirements - That lengthy switch-case might be missing a few cases!
3) Certain kinds of bugs - Typos in parts of the code that affect the post-condition enforcement can be caught.
4) Programmer indiscipline - Perhaps that developer might be missing a few basic but essential checks?

If nothing, it provides a way of ensuring complete coverage and execution of the developed code, an objective that would be difficult or time-consuming to achieve otherwise.

Unit Testing As Claim Validation

2007-08-13T11:57:00.000+05:30

"Give me a lever long enough and a fulcrum on which to place it, and I shall move the world." - Archimedes (Mathematician and inventor of ancient Greece, 280-211BC)

A function is much like Archimedes's lever, a block of code that claims that it will do something if some things have already been done. A unit test should ensure that the function can actually do exactly what it claims to, when all its conditions are met.

The definition of a function, no matter how complex it is, can be decomposed as
1) Preconditions (Conditions/Environment)- Things which must be done or conditions which must prevail when the function is called. These might include constraints on the input parameters and global state variables.
2) Body (Action) - The main block of code which achieves the functionality.
3) Postconditions (Side-effects)- Things that the function will ensure by the time the body of the function finishes executing. These can be the function's return value or the modification of the state of the system.

Unit-tests should determine whether all the postconditions are fulfilled when all the preconditions are fulfilled by the caller of the function. It is important to remember that unit-tests are more like mathematical verification of the function-model; they check whether the code conforms to the definition of the functions.

Unit Testing Primer

2007-08-11T19:05:00.000+05:30

(Breaking this article into smaller, more readable fragments. Blog-style!)

Unit-testing deals with the verification of what an unit can achieve on its own, without help from other units. In other words, assuming all the other modules required by the unit are available, can the unit achieve what it claims to do? This is the question that unit-testing seeks to answer.

I started off a skeptic, regarding the usefulness of having unit tests, seemed to be such a waste of time. What won me over? Simply put, it helps us to avoid stupid, elementary mistakes. But god knows (as do we!) how common those are, especially during bug-fixes!

My primary motivation to write this series of articles is to-
1) define the scope of a unit-test - There seems to be misconceptions about what unit-testing is all about, what a unit-test should and should not do,
2) list the benefits of unit-testing - there's more to it than meets the eye at first sight. All love is not at first-sight!
3) share my understanding(s) - I had great fun exploring unit-testing, especially regarding what could be achieved with dummy or mock versions of external functions (Harnesses)

Here goes...

Unit testing = Claim Validation

Diagnosis Limits

Unit Testing Environment

Test Scripts

Test Harnesses

Example (Read this first if you will!)

Unit-Testing Frameworks

Run the unit-test suite frequently and regularly, especially at integration-points to ensure that development is proceeding in the right direction. Unit-testing can go a long way in -
1) making your team's code bullet-proof and,
2) importantly, avoiding last-minute-release-time-chaos-induced bloopers.

I must also add here that I am not a fan (yet?) of test-driven development. I would recommend unit-testing for finding errors that could easily escape visual checks or code walk-throughs..

- Thomas Jay Cubb

Please also read Learning To Love Unit Testing.

TODO - Diagrams

Draw The Line

2007-07-25T18:44:00.000+05:30

While coding within code-frameworks, we will be required to insert functionality into boilerplate code. There might be lots of TODOs marked in the framework code. When doing so,if what you are doing would be long-term, call hook functions to your own non-framework code rather than coding the functionality in-place.

Call your designed functions through a "hook" function and don't code the functionality within the generated code. Draw the line!

Advantages:
1. It will be easier to move to another framework. Otherwise, there'll be lots of last-minute copy-pasting and hence errors introduced.
2. Better visibility. When something goes wrong, you know who to blame!
3. More room for experimentation. You might want to tweak the framework's configuration and generate new code.

Principles Of Codeline Management

2007-07-03T12:42:00.000+05:30

Might seem like common-sense, but learnt the hard way!

1 Build Inequality
a) What is working on one build might not work on another. We must retain information regarding important working builds to facilitate later investigation!
b) Some codelines are important than others. 10 units of work on a build close to the mainline is probably worth more than 20 units of work on a distant line.

2 Fix Early
Find errors and fix problems at the earliest. Yes, getting things working your build is very important.

3 Merge Early
Get close to the mainline, at the earliest possible stabilization point.

4 Merge And Fix Early
Find errors and fix problems on a build that is as close to the mainline as possible. To paraphrase a proverb, “Early to merge and early to fix makes the release smooth and nice!” ?

5 Useful Artifacts
If an artifact is worth keeping, save it. If it is not worth keeping or it is not likely to be used, remove it.

6 Docubits
Documentation: every bit helps, and a little bit of documentation at every step doesn’t hurt!

Hopefully I will be writing more on each of these points later.

CM Synergy Crash Course

2007-06-20T12:55:00.000+05:30

Bits and pieces of CM Synergy info picked up. Hope this supplements the sparse Synergy documentation. Also posted at the CruiseControl website

Introduction

CM Synergy aka Telelogic Synergy is, "a task-based configuration management system". But the philosophy of the tool is radically different from other version control systems around. These differences sometimes add up and hit you hard; especially if you have prior experience with any of those other tools!

Synergy-ese (Essential)

CM Synergy uses different terminology from other CM tools. Some of these "new" terms are ill-chosen and may take some getting used to. If you are moving to CM Synergy from another tool or are forced to adapt (new job etc), then these rough translations may help you get to speed faster.

Task (almost)= objects
A task is just a collection of versioned objects. Synergy adds the idea that these objects are grouped together for a purpose and hence it is a "task".

Check-out
You check out objects and make changes to them. Synergy recommends that the checkouts must be made against a task. When you check out an object is that it gets added to the task. In effect, you are making the task as you work. When you check out stuff, it becomes a modifiable "working" copy on your hard disk.

Check-in
After you make those changes, you check them in. You can check in the task, Synergy tracks the objects associated with the task and checks in each of those objects. Alternatively, you can also check in objects individually.

Folder = Label, Tag (Do not draw the "directory" parallel!)
Tasks are put in folders. Since a task is a collection of objects, the folder will, effectively, contain the objects that make up those tasks.

Reconfigure = Update
Reconfigure is how you get files from the repository. A set of folders would have been allotted to you within Synergy; when you reconfigure, you would be getting the contents of those folders. The fancy Synergy-ese term for what you get when you reconfigure is the not-for-mortals-sounding "reconfigure template".

Project
A project is a list of the versions of all the files (objects) being used by you.

Finding Synergy

(TODO)

Advanced Synergy-ese (Non essential)

(TODO)

Sync

Reconcile

Get Out Of Jail Free!

(TODO)

Conclusion?

(TODO)

- Thomas Jay Cubb

Root Or Fruit?

2007-04-23T11:06:00.000+05:30

As far as bug-fixes are concerned, there are broadly two ways to go:
1) Remove the cause (Solution!)
2) Mask the effect (Hacks!)

For complex systems, before we can possibly arrive at a complete solution, we will need to work at the problem both ways. Attack the root or attack the fruit? Though it is obvious that fixing the root is the ideal solution, often we have to make do with a combination of the two.

Attacking the cause straightaway may not be such a great idea.
1) Incomplete understanding of the system - You might be familiar only with a part of the system.
2) Time-pressure- How many lines of code can you possibly go through before the deadline?

Magnify the effect! Change the effect into something more drastic. This will trigger new lines of thinking.
Remove the effect! Bugs are caused by code; remove the code!
Take breaks. The a-ha moment will often emerge when you are away!

Biller - Design Of A Receipt Generator

2006-12-15T14:23:00.000+05:30

Problem Specification: SALES TAXES

Basic sales tax is applicable at a rate of 10% on all goods, except books, food, and medical products that are exempt. Import duty is an additional sales tax applicable on all imported goods at a rate of 5%, with no exemptions.

When I purchase items I receive a receipt which lists the name of all the items and their price (including tax), finishing with the total cost of the items, and the total amounts of sales taxes paid. The rounding rules for sales tax are that for a tax rate of n%, a shelf price of p contains (np/100 rounded up to the nearest 0.05) amount of sales tax.

Design

Receipt

A receipt can be viewed as a collection of sold items (hereinafter referred to as receipt-items) which contribute to the receipt’s characteristics like the total amount and the total amount of sales-tax.

Figure 1 – Receipt: Collection Of Receipt-Items

Application

In the application, a receipt has to be generated and displayed. The steps involved would be:

Create a receipt-item.
Add it to the receipt.
Repeat 1 and 2 for all items to be added to receipt.
Display the receipt.

The required attributes of the receipt (from the problem-specification) are an item-listing, total amount and total sales tax. All these are dependent on the individual receipt-items and hence must be characteristics of receipt-items.

Receipt-Item

A receipt-item must provide the following information:

Description
Cost
Quantity
Sales Tax (varies according to sales-tax policy)
Price (The shelf-price depends on the sales-tax)

Figure 2 - Receipt Item

Since Sales-Tax and Price are dependent on extrinsic factors, we implement them as methods (the exact implementation-strategy will be detailed in the following sections). Items 1 to 3 may be implemented as attributes of the Receipt-Item abstraction.

Sales-Taxes

There are two types of sales-tax defined in the problem– Import Sales Tax and Standard Sales Tax - any or both or none of these may be applicable on an item. But essentially both imply an amount to be added as tax.

Figure 3 - Sales Taxes

Both these types of sales-tax have to be rounded up to the nearest 0.05, but at a rate defined by the specific type of sales-tax.

Computing the Price of a Receipt-Item

Essentially, the Price of a Receipt-Item = Cost + Sales-Tax(es)

The price of a receipt-item will depend on the sales-taxes applicable on it. But the tax-policy can vary widely (and wildly!). The implementation of a receipt-item should, ideally, not vary based on such an obviously extrinsic factor, if it can be avoided.

Hence we delegate the responsibility of calculating tax to Sales-Tax entities. And since the number of sales-taxes to be applied may vary from none to many, this entity needs to be a list that could vary. This can be achieved by having the Sales-Tax entity point to the next Sales-Tax entity (if any) and so on.

Figure 4 - Sales Tax Computation: Chain of Responsibility

The price of a receipt-item can be easily determined after sales-tax computation.

Thus, the receipt-item would be able to provide information about both its price and its sales-tax.

Receipt-Item Creation: Sales-tax policy isolation

As mentioned earlier, the sales-tax could vary from time to time. It would be beneficial if we could abstract it from the receipt-generation application. Indeed, why need a cashier be required to know the intricacies of taxation and idiosyncrasies of politicians? J The application shouldn’t change each time the policy does!

What this means in the context of our arrived-at design, where each Receipt-Item will be equipped with a Sales-Tax entity, is that we will need to fit it with different kinds of Sales-Tax entities based on the taxation-policy.

We move such taxation-policy dependent logic/functionality into a separate class (Receipt-Item-Creator) which can create an appropriately built Receipt-Item, once it is given basic intrinsic characteristics of the item being sold. (Surely, it is reasonable to expect the cashier to know things like whether an item is imported, whether it is a food-item, its cost etc.)

Figure 5 - Receipt Item Generation: Builder

Displaying the receipt

We can have a function in the application to display (say, displayReceipt) a receipt. This function is not made a part of Receipt itself because having it so would tie the Receipt class to the Application mechanism (console/window/printer for starters).

Conclusion

We are now capable of implementing the steps of the application to demonstrate receipt-generation.

Create a receipt-item === ReceiptItemCreator.create
Add it to the receipt. === Receipt.add
Repeat 1 and 2 for all items to be added to receipt.
Display the receipt. === Function in the application === Receipt.*,

The consolidated class-diagram for the system is given on the following page. Please note that it does not comprehensively list all the methods and attributes in each of the classes.

Figure 6 - Biller System Class Overview

Design Assumptions and Choices

The primary objective of the system is sales-tax computation.

Sales-tax is calculated per item. In the case where the quantity of the item is more than 1, this makes a difference, whether the sales-tax is applicable on the total cost or on the cost of each item individually. The data in the problem-definition is insufficient to come to a conclusion. Choosing to go with per-item sales-tax.

Items have not been classified as Taxable and Non-Taxable. Instead, we choose to embed a suitable Sales-Tax entity via the Receipt-Item-Creator.

A similar strategy for modifying the description of the item was also considered. But such modification would have been complex (“Imported box of chocolates” or “Box of imported chocolates”?). For the same reason, “imported” was not chosen as a modifier which would append “imported” to the description and Imported-Tax to the Sales-Tax.

It was possible to have a separate class for each Receipt-Item type. The resulting “class-explosion” would not have added much value to the system since we are primarily interested only in sales-tax. In the context of the system, there was not enough difference in the treatment of items based on such type to justify separate classes. The only drawback is that we lose the type (whether it was a book or food etc) in the Receipt.

The operation of the system, as mentioned in the algorithm, is simple enough that sequence diagrams are not needed.

Extensibility

New types of taxes may be applied by sub-classing Sales-Tax.

Major changes in taxation-policy can be handled by sub-classing Receipt-Item-Creator. Slight variations in the taxation-policy can be accommodated by modifying it.

If the type of the item (book/medicine/other) becomes of interest, the behavior can be added to the system by sub-classing Receipt-Item.

Changes will be localized to Receipt-Item-Creator. The application can remain mostly unchanged.

Rounding To The Nearest

2006-11-23T14:02:00.000+05:30

Programming languages and spreadsheets usually have a function to round to the nearest integer. But the task of rounding to the nearest something else comes up every now and again. Rounding up to lowest higher multiple of n, rounding down to the highest lower multiple of n , rounding to the closest n....

Algorithm roundToNearest
-------------------------------------
1. Multiply the amount by the reciprocal of the rounding base (N) you want to round to.
number = number * (1 / roundingBase)

2. Round the result using the built-in function.
number = roundToInteger(number),
where roundToInteger is whatever rounding function you want to use.
In case there is no such function available, you can simulate it. roundUp = integerPart of (number + 1), roundDown = integerPart of (number - 1), roundToClosest= integerPart of (number + 0.5) etc.

3. Multiply the resulting amount by the rounding base itself.
number = number * roundingBase

4. The resulting number is the original number rounded to the nearest rounding base.
result = number

Example 1 - Rounding 123.68 (up) to the next highest multiple of 40
Step 1: 123.68*(1/40) = 3.092
Step 2: 3.092 + 1 = 4.092, integer part is 4. (Did integerCeiling(3.092) )
Step 3: 4 * 40 = 160
Result: 160 is the answer.

Example 2 - Rounding 46.27 to the closest 0.06
Step 1: 46.27 * (1/0.06) = 771.16666666666666666666666666667
Step 2: Integer part of 771.16666666666666666666666666667 + 0.03, 771
Step 3: 771 * 0.06 = 46.26
Result: 46.26 is the answer.

Generalization (Compulsory Philosophical Reflection)
Often, what we have with us may not be exactly what our tool requires or expects. Adjust, make do and un-adjust! More technically, transform whatever is incompatible into a compatible form, do the required operation, apply the exact reverse transform. This is a strategy that is often needed in problem solving and. generally. it works!

U3D - Diagramming & Standardization

2006-11-15T17:20:00.000+05:30

# Importance Of Diagramming
* Complexity
o Inadequacy of tables and text
o Things become clearer visually
* Communication
o Bigger projects, Bigger teams
o Typing Speed x Time != LoC
o Not enough that we know it
+ House plan

# Importance of Standardization
* My diagrams are the best!
o Time and effort
o Hard to be consistent
o Reinventing the wheel
o Onus is on us to do the explanation
* UML = "The" Unified Modeling Language

UML Triple Distilled

2006-10-27T18:16:00.000+05:30

A few months back I had given some training in (the) UML for my colleagues. The course was named UML Triple Distilled (a la vodka and Martin Fowler's classic UML Distilled).

The objective of the session was to present the UML from a non object-oriented perspective, as a communication and diagramming tool. People won't often say this, but, really, you don't necessarily have to be an OO guru to benefit from the UML.

In the coming days, I will be putting up slides from the session over here along with some reflections on the slides. Here's the introductory slide.

SFINAE

2006-10-04T19:45:00.000+05:30

Function templates participate in name resolution for overloaded functions, but the rules are different. For a template to be considered in overload resolution, the type has to match exactly. If the types do not match exactly, the conversions are not considered and the template is simply dropped from the set of viable functions. That's what is known as "SFINAE" — Substitution Failure Is Not An Error.

Subversion - What can be in a name?

2006-09-11T11:06:00.000+05:30

Subversion is the configuration management tool that aims to be a replacement for CVS, the older *NIX . It's pretty decent, although it is not all that sophisticated. Just as well, because the project's purpose-statement does not position it as a do-it-all, suitable-for-all-users thing. It just does what it claims to, versioning and does it pretty well.

But what I love about the tool, more than its features and even though the lack of certain features sometimes irritates, is the name: Subversion. I think the name is just charming, to say the least.

First of all, the word "version" is present in the name and versioning is what it does. You could even think of it as a tool that helps manage "sub-versions" of an object. Think "sub-version" instead of version.

If you think the "sub-version" line of reason is juvenile, then take this. "sub-" as a prefix could mean "Under, lower, below, secondary, inferior". Choose the "under" meaning and lo, sub-version takes the "under version (control)" meaning. :-)

But there's more to it The meaning of the word "subversion" is
1. Destroying someone's (or some group's) honesty or loyalty; undermining moral integrity
2. The act of subverting; as overthrowing or destroying a legally constituted government
This refers to Subersion's aim to be a complete replacement for CVS, that of underming the CVS ethos entrenched in *NIX culture.

Thus the name not only describes what the tool does, but it also embeds within it allusions to its history, culture and ultimate goal... and what's more, the mischief is hidden within the multiple possible interpretations.

What's in a name, anyone?

Freeware UML Tool

2006-06-19T12:36:00.000+05:30

Have found an open-source and freeware tool for making UML diagrams.
It's called StarUML. You can download it from the StarUML.com website.

I used it for sometime and found it to be rather stable and usable. It most definitely is not crippleware. Can't say the same about Poseidon or the other community-edition tools like Visual Paradigm or UMLStudio.

StarUML is definitely recommended, though it is not without its share of glitches.

Degenerate Classes

2006-05-29T19:47:00.000+05:30

A degenerate class is one that has no methods at all.
In C++ it would have a pure virtual destructor.
In java such classes are called “Marker Interfaces”.

Decorator Pattern

2006-05-29T11:15:00.000+05:30

An example to demonstrate the Decorator design pattern which I had contributed to Wikipedia a few months back. It has since been improved and changed over there but thought maybe I should maintain a copy... Read the latest version from here.

This Java example uses the Window/Scrolling scenario


class Window {
    
      public void draw() {
              // Draw window
      }
      public void setSize(int height, int width) {
              // Set window size
      }
    
      // Other Window methods
}

The decorator is given the same interface as the component it decorates. The decorator must be explicitly mentioned as supporting the Window interface for it to be useful in a real scenario; it must have the same type.

Typically, the decorator's methods will only pass requests to the underlying decorated component, but it can also perform operations before and after the call. Then the decorator defines extra methods (decorations) to extend the decorated component's functionality.


class VerticalScroller extends Window {

      private Window myWindow;
    
      public VerticalScroller (Window baseWindow){
              myWindow = baseWindow; // Save the reference, which we will use
      }

      public void draw() {
              //draw the vertical scroller
              myWindow.draw();
      }

      public void setSize(int height, int width) {
              //implement vertical scroller-specific functionality
              myWindow.setSize(height, width);
      }
}

class HorizontalScroller extends Window {

      private Window myWindow;

      public HorizontalScroller (Window baseWindow){
              myWindow = baseWindow; // Save the reference, which we will use
      }

      public void draw() {
              //draw the horizontal scroller
              myWindow.draw();
      }

      public void setSize(int height, int width) {
              //implement horizontal scroller-specific functionality
              myWindow.setSize(height, width);
      }
}

Using the decorator:

We can add a VerticalScroller decorator to a Window, say, theWindow, by saying


      theWindow = new VerticalScroller (theWindow);
      //A vertical scroller gets added to theWindow
      //Constructor internally saves a reference to the old undecorated theWindow

The object, theWindow, will have vertical scrolling functionality after this.

IsDerivedFrom

2006-04-17T12:44:00.000+05:30

From GotW

// Example 3(a): An IsDerivedFrom helper
//
template
class IsDerivedFrom
{
private:
class Yes { char a[1]; };
class No { char a[10]; };

static Yes Test( B* ); // undefined
static No Test( ... ); // undefined

public:
enum { Is = sizeof(Test(static_cast(0))) == sizeof(Yes) ? 1 : 0 };
};

Jargon Clash

2006-03-15T17:12:00.000+05:30

=====================
JARGON CLASH
(C) 2006 Thomas Jacob
=====================

Introduction
------------------
The construction of a system is a progression from one stage of clarity to the next.

1. We start with hazy requirements - It's a three-line requirement doc!
2. We try to gather more details - Now, what could this be?
3. We feel we have achieved enough clarity - Oh, that's what he meant!
4. We start to implement the system. - What could go wrong? It's clear and easy.
5. ...and yet, in the final count, the system fails to match the user's expectations/requirements.

Often, the problem lies in the inaccurate representation of facts and requirements. In this article, we explore one of the causes for this.

The Quest For The Holy Grail
-----------------------------------------
The importance of capturing the requirements correctly (as a "Requirement-Model") cannot be overemphasized. After all, the system is built to satisfy the requirements of the users. If we understand the requirements incorrectly, we have an inaccurate Requirement-Model, and the system (which is based on it) will not, cannot be successful.

A major obstacle in our quest for the perfect Requirement-Model is the lack of in-depth knowledge about the field in which the system will be used. This is unavoidable as one cannot be an expert in everything. And that's just as well because what's required of a maker of a paintbrush is that he should be able to make the paintbrush well, not that he should be able to paint well! There is no need for the designer of a CD-player to be a composer as well (though of course, it helps the cause if he "understands" music). It's horse for courses and that's why you have been chosen to develop the system and not the user.

Drinking From The Poisoned Cup!
-------------------------------------------
We need to close the gap in our understanding of the requirements (The system needs to be built, right?) by asking the users for further details. The users might explain things in a seemingly familiar language, but the words could mean something entirely different than the meaning you got. Beware of Jargon-Clash! The user and you, both are experts, and experts, almost as if by definition, tend to use jargon. What you hear and get may not be what they mean!

A trivial, stupid(?) and impossible(?) example: You are implementing a distributed system for a retailing chain. The user says that the client needs to retain the bill. You could very well take thisthis down and, justifiably, note that the bill information needs to be stored at the client-side and go "Wow! Finally...I get to do distributed databases!". Probably all the user would have meant was the the customer (client for the user) needed to be given a printed bill!

Another, closer-to-reality example. The term "ATM" would mean "Automated Teller Machine" (the cash-dispensing type) to the "normal" user but to a networking professional, ATM would mean "Asynchronous Transfer Mode", a technology for networking. What then would an ATM network be? And couldn't there be ATM networks which use ATM technology for the network? Think about the very-many ambiguous conversations possible!

The Jargon-Clash isn't limited to the "unsavvy user, savvy developer" system-construction scenario either. In fact, the more similar the jargon of the user and the jargon of the developer, the higher the probability and impact of Jargon-Clash is. What's worse is that the Jargon-Clash will be less obvious. The effects may become evident only at an advanced stage of the project.
Example: Computer networking and telecom are closely related, especially in this age of Internet telephony. But the term TCP, for a network programmer, would refer to the TCP/IP communication protocol and to the telecom profession would mean a Trunk Control Program.

It also helps if the user too could be made aware of Jargon-Clash. Jargon-Clash could lead to destruction of mutual respect between the user and the developer. But surely, everybody knows what pinging is! How can he be so stupid? The situation now would be, as Strother Martin's character wryly observed in the film Cool Hand Luke, "What we've got here is failure to communicate." Every concern, every requirement is not conveyed and the accuracy of the Requirement-Model is affected.

For want of a nail, a kingdom can be lost and for lack of an accurate Requirement-Model, a system will be doomed to fail.

Poison Is The Cure
-------------------------
Pass everything the user says through the filter of Jargon-Clash awareness.

Try to agree upon a common vocabulary and clearly define each term of relevance. Make a glossary or a project-specific dictionary. It is very important to disambiguate, not only for the accurate elicitation of requirements from user, but also for the ease of implementation.

Construct new terms (a new jargon) if needed, if doing so would -
a) make things less ambiguous, and
b) improve the effectiveness of communication.
Alternate styles of capitalization or the merging of words would suffice in many cases to remind the reader/user that we are using the term in a special meaning.

It bugs readers no end to see repeating groups of words. Think "documentation of user-requirements" instead of Requirement-Model or "the problems caused by the common terms in the user's and developer's jargon" instead of Jargon-Clash. Abbreviate effectively, but do not make things too abstruse.

Validate your Requirement-Model with the user if possible, and then, using the mutually-agreed-upon non-ambiguous vocabulary. If properly validated, the Requirement-Model would simplify the onerous task of system-development considerably.

Summary
------------
Ambiguous terms corrupt the Requirement-Model.
Equivocal Requirement Model = A Failed System.
The corruption propagates and gets magnified.
The developed system turns out to be different from what is required.
Users ditch the system. Wasted time, wasted effort.

Beware of Jargon-Clash.
Disambiguate, at any cost.
Even by inventing a new jargon!

- Thomas Jacob

=================================================================

Advice for language designers

2006-03-04T19:55:00.000+05:30

I strongly felt then, as I still do, that there is no one right way of writing every program, and a language designer has no business trying to force programmers to use a particular style. - Stroustrup

dynamic_cast prerequisite

2006-03-04T19:53:00.000+05:30

A dynamic cast is performed run-time. A prerequisite for using the dynamic cast operator is the existence of at least one virtual member function in the base class.

On The Naming Away - I

2006-02-28T17:09:00.001+05:30

The importance of the names that we give variables and functions cannot be overemphasized. I would even go so far as to say that, at times, proper naming is more important than the functionality being coded itself! Sadly, in the mad rush to get things working, this aspect of coding is often neglected. :-(

Remember: code is also for reading!

Template Friend Functions

2006-02-19T19:31:00.000+05:30

code snippet picked up from the net. don't remember where.


#include
using namespace std;
template
class SomeClass{
   private:
       T member;
   public:
...
   friend ostream& operator<<(ostream &,SomeClass &);
};

template 
ostream& operator<<(ostream &os, const SomeClass&some){
          os<<"( " << some.member <<") ";
          return os;
}    

int main(int argc, char* argv[])
{
SomeClass sc(5);
cout << sc; // Problem????
return 0;
}

It reported that operator << was not found.

The problem is that in the class definition, a friend was declared as a function, not a template function. To make the code link properly, the friend declaration should be changed to:


 friend ostream& operator<< <>(ostream &,SomeClass &);

Just another little C++ twist.

Attack Of The Clones

2006-02-02T14:04:00.000+05:30

Presque vu: is a French term which means "almost seen". It is the feeling of very nearly, but not quite, remembering something.

Here are three operating system projects that attempt to recreate or provide the look-and-feel and user-experience of other operating systems. They are driven by fervent nostalgia, but could they, will they, ever be "even better than the real thing?

1. ReactOS - Aims to provide an implementation of a Windows® compatible OS
ReactOS homepage

2. Haiku - Aims at the re-creation of the Be Operating System.
Haiku OS homepage"

3. CoLinux - port of the Linux kernel that allows it to run alongside another operating system on a computer. Run Linux on Windows® 2000/XP.
Cooperative Linux Homepage

Indirection Is Flexibility

2006-01-23T18:04:00.000+05:30

Indirection (n)
1. "indirect procedure or action".
2. "deceitful action that is not straightforward"

Indirection in system design is when instead of explicitly specifying how exactly something is done, we delegate the responsibility to another person/entity. We buy belts that are looser than needed, just in case we get fatter, don't we?

Let's say somebody who's new in town asks us what he should do to start a bank account. We could -
a) tell him to go to the bank and meet the manager there.
b) give him the exact list of required documents, the order in which to submit them and to whom.

Take into account the always-changing laws and the idosyncrasies of different banks, and the advantages of the first approach are self-evident! That's indirection for you. We would of course give him the address of the bank and possibly also the title of the official (manager, if he is a life-newbie as well).

Indirection helps us surmount change. In programming, we achieve indirection through the use of pointers and references instead of actual objects. Indirection is closely related to the concept of abstraction.

OO perspective: Instead of specifying the exact type of the implementor, we just mention that it will be of a certain type,say, Base . This is the foundation on which most design patterns are constructed. We can later on replace this reference with a more specialized object (derived from Base), if needed, to provide extra/changed functionality.

Other examples:
The use of virtual machines like .NET's CLR or Java's JVM instead of the actual processor gives us portability as a useful side-effect.
The use of pointers in C/C++ gives us space-efficiency.

There ain't no such thing as a free lunch. Indirection gives us flexibility at the expense of performance. No matter how trivial the cost is, there is a price to be paid. You can't have your cake and eat it too!

OS Development Resources

2006-01-08T19:25:00.000+05:30

A new year's present for the wannabe OS developer

http://www.osdever.net/tutorials.php?cat=0&sort=1

May you not fail for the lack of guidance!

T&L - Not Made For Each Other?

2005-12-07T10:27:00.000+05:30

---------------------------------
THREADS AND LIBRARIES
NOT MADE FOR EACH OTHER?
---------------------------------

1 INTRODUCTION

Threading libraries hide very little of the complexity involved in the use of threads. Often, the focus and the major obstacles in implementing a multithreaded system are the low-level details of threading, rather than the problems that the system is designed to solve.

Objects can be said to model reality, thereby providing good abstraction. However, a crucial part of reality that is not represented adequately in an object is a sense of time. Objects exist in time and space, and interact with other objects; they have "life". A mechanism for intuitively expressing such Live Objects (or Active Objects), where an object has its own thread, is missing from the threading libraries in (libraries of) object-oriented languages today.

Spatial representation OK.

Temporal representation, not OK.

2 CURRENT THREADING MECHANISMS

Presently to use threads, we create a thread and give it sections of code (from the object) for it to do. For example,

threadHandle=CreateThread(StuffToDo , OS/LibraryParameters)

is how threads of control are created from the program. The code (StuffToDo) is then executed in the newly created thread.

2.1 Observations

In the present library implementations,

2a Threads use objects.
The thread executes a function, possibly a function or method of an object. In the example, StuffToDo could be the method of an object.

2b Threads are to functions what objects are to classes.
Or, threads are objects. The thread object instantiates a function, brings into execution-space so to say, executing it. The implementation forces the thread to become a first-class "object" in the program-space. It has a handle, threadHandle, that can be used to refer to it.

2c Threads are almost equivalent to operating system threads.
Most of what can be done with an operating system thread can be done with library threads also - one can suspend a thread, resume it, abort it etc

3 'OBJECT'IONS - CRITIQUE

In the real world, entities use their time and their resources to do things. A thread can be viewed as a flow of time for practical purposes. In the library-model, threads use objects (2a) whereas in reality, objects use threads. This unnatural modeling contributes to the difficulties of conceptualizing and implementing threaded systems.

It should be "Objects use threads",

not "Threads use objects".

An object oriented program/system is an exchange of messages between objects resulting in side-effects useful towards the solution of the problem at hand. Thread objects (2b) are only an implementation mechanism, a way of calling a function; they do not help to manage complexity. Instead, thread object interactions add complexity and intrude on the main logic of the program.

In the scenario of single-threaded program development, come to think of it, the programmer plays the role of the thread object during coding- deciding which functions to call and in what order. Sadly though, this does not scale - which is why multithreaded programs are so challengingly complex.

Why have thread objects at all in programs? Threads are, very much, operating system entities (2c) . If we have the thread object in the program, it is only natural that they have methods similar to the real-world (albeit on the OS-side) entities that they model, with some high-level constructs thrown in for good measure. If we have thread objects, the complexity of threading cannot be hidden from the programmer.

For operating systems, threads are expensive to manage. The objection to live objects that is raised all too often is: "What! If I have a 1000 live objects, it would mean 1000 threads too? You must be out of your mind..." This mental block must be removed. The programming language back-end (the popular idiom of the runtime) can possibly be adapted to meet the external implementation constraints.

Hide the complexity of threads from the programmer, effectively.

4 OOTOPIA

Ideally, after the definition of live objects, one would be able to program like a classroom interaction like this:

void main()

{

TeacherLiveObject theProf;

StudentLiveObject theStudents[30];

}

That would be it?

5 CONCLUSION

A LOOP (Live Object Oriented Programming) language is the need of the hour. Such a language would help people to take their minds off low-level threading details and focus on more domain-relevant issues at hand, enabling the construction of more useful programs.

- Thomas Jay Cubb

External links
1 The Free Lunch Is Over
2 Software and the Concurrency Revolution
3 Discussion on Active Objects In Python
4 IBM Research- The X10 Programming Language - A LOOP language?
5 Polyphonic C# in Cw - Another LOOP language?

Cline's Commandments

2005-12-06T19:18:00.000+05:30

* A class Fred's assignment operator should return *this as a Fred& (allows
chaining of assignments)
* A class with any virtual[20] functions ought to have a virtual
destructor[20.4]
* A class with any of {destructor, assignment operator, copy constructor}
generally needs all 3
* A class Fred's copy constructor and assignment operator should have const in
the parameter: respectively Fred::Fred(const Fred&) and
Fred& Fred::operator= (const Fred&)
* When initializing an object's member objects in the constructor, always use
initialization lists rather than assignment. The performance difference for
user-defined classes can be substantial (3x!)
* Assignment operators should make sure that self assignment[12.1] does
nothing, otherwise you may have a disaster[12.2]. In some cases, this may
require you to add an explicit test to your assignment operators[12.3].
* In classes that define both += and +, a += b and a = a + b should generally
do the same thing; ditto for the other identities of built-in types (e.g.,
a += 1 and ++a; p[i] and *(p+i); etc). This can be enforced by writing the
binary operations using the op= forms. E.g.,


      Fred operator+ (const Fred& a, const Fred& b)
      {
        Fred ans = a;
        ans += b;
        return ans;
      }

This way the "constructive" binary operators don't even need to be
friends[14]. But it is sometimes possible to more efficiently implement common
operations (e.g., if class Fred is actually String, and += has to
reallocate/copy string memory, it may be better to know the eventual length
from the beginning).

ISO C++ updates

2005-12-04T19:49:00.000+05:30

A static const integer member is the one instance in C++ in which a class member can be initialized explicitly within the class definition, thereby making the value available to other constructs within the class, such as the dimension size of m_buffer. Without this construct, the use of an enumerator as a symbolic constant was a common workaround.

There is now covariant return type support in the definition of virtual functions. This is great news for those who write class hierarchies.

There is support for the implicit return of 0 within main.

Heart For The GNU

2005-11-29T11:55:00.000+05:30

This short poem tries to encapsulate some Linux history.

Linus Torvalds wanted to modify Andrew Tenenbaum's MINIX operating system initially. But Tanenbaum did not give him permission, so he set about writing his own operating system. This became the kernel for the GNU project which aimed at making a free operating system.

--------------------------------
A HEART FOR THE GNU
--------------------------------
Tanenbaum forbade,
Linus obeyed.
Fiat Linux!
Freedom redux.

- Thomas Jay Cubb

Notes
--------
1. "Fiat Lux" is a Latin phrase meaning "let there be light" from the Bible's Genesis book which relates God's creation of the world. Linus, the Creator! So, Fiat Linux.
2. redux = Brought back. The GNU OS project was losing steam and face, for the lack of a suitable kernel for its operating system. The Linux kernel, so to say, resurrected it. (GNU/Linux)

You may also be interested in reading Punnix.

On The Hacked Track

2005-11-28T17:24:00.000+05:30

1. Viewing the dependencies of a binary
ldd gives you the dynamic libraries that a file depends on.
$ ldd binaryfile

2. Viewing the symbols in a file
nm gives you the list of symbols in the file. Functions that are exported by the library will be present as symbols. Many files are stripped of symbols before they are released, though.
$ nm binaryfile/libraryfile

3. Interposing
On many *NIX variants, you can set a dynamic library of your choice to be searched first when dynamic library calls are made. Set the value of LD_PRELOAD to the full path of the library file you want to be executed in preference to other libraries.

Take an executable and determine its dependencies. View the symbols in those library-files. Make your own library-file with implementations for the symbols that seem to be of relevance to you. Set the LD_PRELOAD variable to the name of your library file. Run the executable.

Data Polymorphism

2005-11-22T14:37:00.000+05:30

INTRODUCTION
----------------------------

Languages that support polymorphism seem to require functions to model polymorphic requirements. This suffices in most cases, but there are cases in which it is only the data that is polymorphic - what takes a different form in a different context.

While modeling data polymorphism is possible through the use of templates (will be discussed in a later post), this article makes a case for the language to allow interfaces to have abstract data members, whose types are unknown in the base class and will be meaningful only in the derived context.

Interfaces (and Abstract Base Classes) are an expressive notation for mandating the implementation of required functions in derived classes. Why not utilize the same notation to accommodate data as well?

In a nutshell, the following is possible :-

class Abstract
{
virtual void pureVirtualFunction()=0; //Unknown behaviour, specifiable
void concreteFunction()
{
 pureVirtualFunction(); // We can call the undefined function
}
};

But the following is not :-

class Abstract
{
virtual pureVirtualData; //Unknown data, Not allowed

void concreteFunction
{ 
  print pureVirtualData.Count; // We know how to use the data though
}
};

What does this imply? Could there be cases where such a feature would help?

Some months back, I encountered a requirement which, I thought, really called out for more direct support for data polymorphism in the language. I explain the problem in a generalized way, leaving out some domain-specific details.

Please do let me know if more details are needed to understand the problem and why the limitations mentioned are significant.

THE REQUIREMENT
--------------------------------

An algorithm needs to be implemented on the transmissions of an existing client-server system to improve its performance. Broadly, the algorithm transparently intercepts the packets, applies some transforms based on the packet and relays them.

In order to implement the algorithm, components should be deployed at both the server and the client. The algorithm depends on the functionality in a packet and a factor which is determined by whether the component is at the server or at the client.

DESIGN WITH BEHAVIOURAL POLYMORPHISM
----------------------------------------------------------------------

Packet is a concrete class which provides a buffer-storage area and some domain-specific functionality.

class Packet
{
Byte Buffer[];

virtual double toDouble();
virtual int toInteger();


void applyXXXToPacket()
...//Other domain-specific functions
...
};

The algorithm depends on Packet functions to transform the packets with a factor which is based on Packet::toDouble() and on Packet::toInteger(). Both these conversions are to be done slightly differently from the implementations in the Packet class and, also, differently at client- and server- sides.

We have the inheritance,
ServerPacket: public Packet, and we reimplement toInteger and toDouble for server
ClientPacket: public Packet, and we reimplement toInteger and toDouble for client

Algorithm components only need to apply some transforms on Packets. We generalize to the abstraction,

class AlgorithmComponent
{
Packet& p; //Reference type required to achieve behavioural polymorphism

void ProcessPacketXXX();
... //Functions which use Packet::functions
... //
};

The component implementing the algorithm only differs slightly on the server and client sides. But they do differ and so we have the specializations,

ServerComponent: public AlgorithmComponent
ClientComponent: public AlgorithmComponent

It worked! But...

PERFORMANCE ISSUES...
--------------------------------------

It turned out that both the required conversion functions were very expensive, leading to erratic performance. All that was really required was a one-time computation of the conversion, which could be done in the constructors of the specialized Packets. Saving these in a member variable would solve the performance issues.The ClientComponent and the ServerComponent could then use this saved value directly.

But it is not possible to for the generalized AlgorithmComponent to access a data member of the generalized Packet class through a Packet reference and get the implementations of the derived classes.

Consider the code snippet below.

class Base{
public:
 int i;
 Base(){i=2;} //In B, i is 2
};

class Derived:  public Base
{
public:
 int i;
 Derived(){i=5;} //In D, i is 5

};


void main()
{
 Derived d;
 Base& b=d;
 cout << class="cpp-comment">//Prints 2, not 5. No polymorphism for data access. :-(
}

This means that the abstraction of AlgorithmComponent would collapse - breaking the class hierarchy.

...AND A TRIVIAL(?) VIOLATION OF A DESIGN CONSTRAINT
------------------------------------------------------------------------

An AlgorithmComponent necessarily has to be either server-side or client-side. It was just an abstraction of design which accurately summarized the operation of the algorithm. AlgorithmComponent should not be instantiable, it is an abstract base class by nature.

Implementing this particular design constraint is possible if we make the functions which depend on Packet pure virtual. Technically, for AlgorithmComponent to be abstract, we need to make only one of the ProcessPacketXXX()s pure virtual. But that would not accurately model the dependency on Packet for the other functions.

Functions that depend on Packet can be completely specified. We could avoid code duplication if we code it in the base class itself. The abstractness of AlgorithmComponent is because of its dependency on Packet. So, Packet is what should be pure virtual really.

What we should have had was an AlgorithmComponent with completely specified functions but with an unspecified Packet that had to be compulsorily supplied by the derived class.

CONCLUSION
----------------------

What if, in the discussed example, ServerComponent depended on a double/class Foo and ClientComponent depended on an int/class Bar? Shouldn't abstract base classes be allowed to have undefined data members? Or equivalently, why not allow data members in interfaces?

Workarounds to these do exist -
1) with templates (the discussion stopped just short of it, don't you think?) - but it would be a compile-time solution. Will be discussed in a later post.
2) with composition instead of inheritance (which is how we chose to implement it finally) -but lacks the simplicity and elegance of the explained design - with code duplication and what not.

Would it not be simpler and cleaner to express such a design if the language just allowed the data also to be truly polymorphic?

- Thomas Jay Cubb

Everything Changes

2005-11-21T15:37:00.000+05:30

-------------------------------
EVERYTHING CHANGES
-------------------------------

Systems are built to satisfy the requirements of users. Successful systems -
a) meet those requirements and,
b) will continue to be used by the users, who would prefer it to any other.

It is possible for a system to succeed even if it is not flexibly designed. My system does the job and they like it! These are the requirements, my system is designed for that! Who cares that it is not flexible! I have done the requirement-collection to perfection. There's nothing more they could possibly want!

Now who wouldn't want his system to be successful? In fact, most people would want their creation to be indispensable! But with great power, comes great responsibility. Good design is all the more essential if your system has even the remotest chance of being successful - if you want to be a star, not just a shooting star.

Successful systems will be used by the users and, over a long period of time. Any successful system will, in the course of its lifetime, be required to accommodate changes. No matter how well you did the requirement-collection, over time, the set of users will change and by extension, the requirements too! All of a sudden your "successful" systems becomes a failure. Users choose to switch from the system

We must be able to adapt and quickly at that. Accommodating new requirements or changing the behaviour should not become an unnecessarily complex or time-consuming chore - requiring the complete revalidation of the system. Resilience to change is one of the hallmarks of a good design.

Changes in a system may be required because -
a) The users of the system have new requirements. Wouldn't it be cool if this thing could do that as well?... I want to use my credit-card to pay..... or ... I want this bus to fly!
b) Better, more suitable ways of doing things may emerge only after the system is deployed. Would it not be better and simpler to do it like this?... I want the system to start when I press the end button...
c) There were slight errors in our understanding of the requirement. Largely unavoidable. Because only hindsight is 20/20. Oh, was that the order in which you wanted things to happen?... The person should be given the receipt before he pays....

While bus-to-airbus scenarios are well-nigh impossible to design for, with a little bit of thoughtful design, the other two can be designed for more easily. What's more, often you will find that many of the seemingly bus-to-airbus requirement-changes could have been handled in less cumbersome ways, if only you had thought about possible changes during design.

-Thomas Jay Cubb

SunOS vs Solaris

2005-11-16T14:37:00.000+05:30

What's the difference between SunOS and Solaris?

SunOS refers to the actual operating system that underlies the Solaris OE (operating environment). SunOS is often used to refer to the old SunOS 4.x, a BSD-like operating system with some SVR4 features and OpenWindows.

Solaris is typically used to refer to SunOS 5.x releases of the operating system and environment from Sun Microsystems. The version of Solaris can be derived from the SunOS 5.x designation by dropping the leading 5. e.g., Solaris 7 is SunOS 5.7. However, some earlier verions of Solaris were numbered as 2.5.1 with a SunOS release of 5.5.1.

Peter Deutsch's Eight Fallacies

2005-11-14T12:45:00.000+05:30

Picked this up from digg.com

-----------------------------------------------------
The eight fallacies of distributed computing
By Peter Deutsch
-----------------------------------------------------

Essentially everyone, when they first build a distributed application, makes this eight assumptions.
All prove to be false in the long run and all cause big trouble and painful learning experiences.

1. The network is reliable
2. Latency is zero
3. Bandwidth is infinite
4. The network is secure
5. Topology doesn't change
6. There is one administrator
7. Transport cost is zero
8. The network is homogeneous

Finding Bliss - UNIX find Introduction

2005-11-10T18:04:00.000+05:30

----------------------
FIND-ING BLISS
----------------------
The UNIX find command is, in my book, one of the most powerful time-saving utilities ever. I would even go so far as to say that you have not appreciated the power of UNIX utilities fully unless you have used, and can habitually use, the find command.

What's more, it it offers great flexibility and power. Not only does it allow you to find stuff, but it also allows you to invoke a command you specify, on each item it finds.

STEP-BY-STEP EXAMPLES
-------------------------------
1. Finding stuff
$ find /
gives you a list of everything that's under the / directory. And that, as far as your system is concerned is everything under the sun. You can replace / with any other directory of your choice.

2. Finding a file based on name
$ find / -name foo
finds all items (files and directories) named foo, on your system. You can specify wildcards if you wish but remember to escape shell expansion for the wildcard by using quotes.

3. Getting a list of all directories on your system
$ find / -type d

4. Executing a command on what find found
$ find / -exec ls -l '{}' \;
generates a detailed ls listing of each item found in the system

This needs a little bit of explanation -
-exec specifies that what follows is a command
\; denotes the end of the command
'{}' is where the current item gets substituted in the command for each item.
You can give any command you want instead of ls, of course.

NOTES
---------
1. -name, -type and -exec are like extensions to the basic find utility, which builds a list of everything under a directory. It spiders the subdirectory structure and builds a list.

2. Think of -name and -type as filter conditions for cutting the list down to just what we need. For example, -type f means files and -type d means directories.

3. -exec specifies the action to invoke on each item - whatever is between exec and \; gets taken by find as the command.

4. There are many more modifiers. Please refer to the man pages on your system. These only serve as quick but useful intros.

PUTTING IT ALL TOGETHER
----------------------------------
Let's say you want to view and edit all readme files under a directory, say, /home using an editor, say vi. Think about it.

You can accomplish this in one line with the find command.
$ find /home -type f -name readme.txt -exec vi '{}' \;

So much less troublesome, less strenuous and less time-consuming than getting a list of the files and clicking on them one by one. All in a line's work!

ON THE DESIGN
(external view)
---------------------
find allows you to iterate over a filtered collection invoking a specified action. Call it... I'm-making-it-up....the Moulding Iterator design pattern if you will. I have found that this is an extremely common problem, it deserves a name, so forgive me!

find epitomizes the engine-addon idiom. At its heart, it is a list generator which has the capability of spidering directory structures. The list generator has unobtrusive facilities for filter conditions, to be used if needed and specifying the action to , if needed. Unobtrusive: if you want the feature, you can use it; if you don't care about it, no need to bother even knowing about it.

Flexibility=Good design. find has its limits, yes, but considering the fact that it was designed when it was, it's very, very good indeed. find out for yourself!

- Thomas Jay Cubb

Printing Call-Stack Tracebacks

2005-11-06T13:01:00.000+05:30

pstack on Solaris gives you a stack dump for all active threads. But this might be too heavy for some applications.

libunwind is a Linux library that provides stack unwinding routines.

The link below gives a method of doing it with functions on Solaris.
techno's scratchpad: C/C : Printing Stack Trace with printstack() on Solaris
But this works only for Solaris 9 onwards...

Check this for some Linux info
http://www.codecomments.com/archive286-2004-7-236422.html

For Windows information
http://www.codeproject.com/threads/StackWalker.asp
Homepagehttp://blog.kalmbachnet.de

Abstract Class

2005-10-22T19:13:00.000+05:30


class AbstractClass  
{
public:
 void bar();
 virtual void foo() = 0; //function not defined
 AbstractClass();
 virtual ~AbstractClass();

};

void AbstractClass::bar()
{ 
 foo(); //calling the undefined function
}

This code will compile.

Why not CON?

2005-10-14T09:28:00.000+05:30

Received a forward today.

>An Indian discovered that nobody can create a folder anywhere named as
>"con "

>This is something pretty cool...and unbelievable... At Microsoft the whole
>team, including Bill Gates, couldn't answer why this happened! Try it out
>yourself...

The first part of the excerpt is true. But the second is probably (I hope) an exaggeration!

The reason for the restriction is that CON is the special name for the computer-console in DOS and the command-shell. CON is a device name; to create a file from the command-line, we would say COPY CON filename and then type the contents of the file, stoppping with a Ctrl-Z (the DOS end of file indicator) and pressing ENTER. And because filenames are case-insensitive, no variant of CON will be allowed.

Other names not allowed as file/folder-names include: PRN, LPTx, COMx - all device-names.
But interestingly for COMx, even if you have 4 COM ports, COM5, COM6 etc aren't allowed!!! So, does this mean Windows won't allow more than 9 COM ports??? Why not? That would be the real restriction!!!

Finding the space gobblers

2005-10-04T19:42:00.000+05:30

Find out top 10 directories eating up your disk space:
du -cksh * | sort -rn | head -10

Google And The Truth

2005-10-04T16:28:00.000+05:30

"Google first, think later. " is the mantra that everybody, especially the software professional, lives by.

1. There is a problem.
2. Nothing new under the sun.
3. It must have been faced by someone else too.
4. Somebody must have solved it back then.
5. Why reinvent the wheel?
6. Let's get it solved. ... fast.

In this age of instant karma and instant nirvana, the top search result is what becomes the objective truth for the vast majority..

What cannot be found might as well not exist. - TJ

Punnix Version 1.2.0

2005-09-20T10:59:00.000+05:30

--------------------------------------------------------------------
PUNNIX Version 1.2.0, or a song of Linux
-Thomas Jay Cubb
Note: All puns are intended, but may not be indented!
-------------------------------------------------------------------
Trapped behind closed gates, windows
I was looking for a way out
Of the morass of proprietary property.
‘Cos I was buried by the hefty software bills.
I wondered, why should I
be a slave to that GUI ?

Proprietary software and operating systems place restrictions on your use of them. You might have bought it but it's still not yours! You are not free to use it like you would want to or tailor it to your requirements.
GUI, usually pronounced as “gooey”, is to be pronounced as “guy” here for both rhyme and meaning.

And then in an epiphany,
The flightless angel Tux,
(Or perhaps it was a friendly gnome?)
He showed me the way to a universe
Of Enlightenment,
Home of users (e)X-Windows.

GNOME, which stands for GNU Network Object Model Environment, is a desktop environment usually bundled with Linux. A gnome is also a magical being that guards treasure (how true!!).
Epiphany is a web-browser for GNOME.
Tux is the name of the Linux mascot – that cute penguin.
`The X Window System’, commonly referred to as just `X’, is (generally) the graphical environment for Linux.
Enlightenment is a window-manager for X.

The magic-mantra
say perforce
Floss! Open Source!
Lilo! Behold
A free GNU world unfold.
A la Ali Baba
I could not but gawk
At the unhidden treasures
That I now could mount!
How blind I had been
Not to have before these perls seen.

With Open Source software, the source code is open for you to use and modify.
FLOSS (Free/Libre/Open Source Software) is a term that covers both open source and free software. The author urges you to floss your PC!
LILO (LInux Loader), is a boot-loader that loads Linux for you. LILO has pretty much been replaced by GRUB (GRand Unified Boot-loader).
GNU stands for “GNU’s Not Unix”. Such acronyms are called recronyms.
gawk is a pattern-scanning tool.
mounting is how you access resources in Linux. You mount things, use them, and unmount them.
perl (Practical Extraction and Reporting Language) is a powerful scripting language that comes along with Linux.

It was as if
I was Bourne again.
No more rodent-fatigue that lingers
I have discovered use for my fingers!
etc.

bash (Bourne Again SHell) is a command-shell, the command-line prompt of which is where you enter commands. Oh yes, there used to be a Bourne shell too!
/etc is the directory where configuration details are usually stored.

***ROOT ALMIGHTY***

When I’m at the command line
Computer, obey the command mine.
For I am the Mandrake root,
I’ll slash all I want
Or backslash as is wont.
I might be mad as a Red Hatter
But in my kernel is a
A smouldering Caldera
Of raw, unbridled power.

Mandrake, Red Hat and Caldera are distributions of Linux.
root is the name of the super-user (user with administrative privileges) in Linux.
Mandrake-root is a narcotic/hallucinogen supposed to have magical powers. Indeed, Mandrake-root can make you mad as a hatter!
Slash (‘/’) and backslash(‘\’) are important keyboard characters for a command-line user.
The kernel is the heart of the operating system – that pumps life-blood into your PC, so to speak.
A caldera is a large crater at the top of a volcano.

I am Root Almighty,
God of the process-tree.
The world of demons, I am init.
Full control,
no holds barred.

To say that the root or super user is accorded God-status in Linux is by no means an exaggeration. If you are root, then you are all-powerful.
Processes are programs which are being run. Linux organizes the processes as a tree.
daemons are processes that operate in the background and provide services.
init is the very first process that is started when Linux boots. init starts the rest of the processes, including daemons.

I will tweak,
As is my custom,
till they squeak.

I wave the two-pronged fork
Children brought by the fabled stork
Ampersand when I kill
Become orphans or zombies.

Processes have a life of their own. forking is the method by which new processes are created, nay, born.
The new processes are called child-processes of the parent-process (what else!)
According to an old wives’ tale, storks bring children.
You can make any process run in the background by adding an ampersand (‘&’) when calling it. You can kill a process too. What is born must die! Orphans are child-processes whose parents have been killed and zombies are processes that are undead. Creepy?!

*** END OF ROOT ALMIGHTY***

Welcome to the free world!

Where you will no longer be told where to start.
Or commanded to issue the salute three-fingered
Even when it’s the OS that erred.
No longer be treated like minnows
Get to know more than that best Win knows.
No need for that software toss
Head or tail
More or less
I have made my choice.

The three-fingered salute is the dreaded Ctrl-Alt-Del key combination that one is forced to press in order to reboot a PC. Also called the `Vulcan nerve pinch’.
head is a program that shows the beginning of a file while tail shows the ending of a file.
more and less are programs that display a file one screen at a time. They are more or less the same. Except that less has more functionality!!! Yeah, you read that right.

If you have drunk the milk of the GNU
You will crave nothing Moo!

A gnu is also a large African antelope with a head resembling that of an ox.

- Thomas Jay Cubb

------------------------------------------------------------------------------------------------
CHANGE HISTORY

Version 1.2.0
1.Integrated man-pages inside the poem.
2.Added "floss!" line in poem
3.Changed and added some documentation
4.Moved "tweaking" para into "Root Almighty" section
5.Obfuscated proprietary-software bashing.

Version 1.1.0
1.Documentation "Punnix man-pages" added.
2.Line 3, Proprietary `propriety’ changed to Proprietary `property’
3.Line 5, ‘I wondered’ added
4.Line 17, Free ‘new’ world changed to Free ‘GNU’ world.
5.Line 22, how ‘stupid’ changed to how `blind’
6.Line 23, Not to have this before seen changed to ‘Not to have before these perls seen’
7.Line 24, `I’ changed to `It’ Had been a typo.
8.Couple of lines deleted (“I have…the key”)

Version 1.0.0
1.Initial version
------------------------------------------------------------------------------------------------

LICENSE

You may freely distribute copies of this post. But please retain this license message and do not modify the contents of the post. Please feel free to quote this in full or in part, anywhere you will. The author reserves the right to be identified as the creator of this poem and any part of it thereof. You can contribute to the evolution of this work by writing in with comments. Please do so!

-Thomas Jay Cubb,
Author
------------------------------------------------------------------------------------------------

C++ Name Origin

2005-09-06T15:24:00.000+05:30

Rick Mascitti was the person who coined the term "C++". Before he did so, C++ was called C With Classes by Bjarne Stroustrup.

Some interesting quips can be found at
http://en.wikipedia.org/wiki/List_of_computer_term_etymologies#C and
http://en.wikipedia.org/wiki/C_Plus_Plus#History_of_the_name_.22C.2B.2B.22

I've also heard rumours that Java was called (likely in a lighter vein) "C++ --" !!
:-)

Copy-Paste and x-Handedness

2005-08-29T17:52:00.000+05:30

The de facto key-combination for copy-pasting, the programmer's butter-knife, for most people is Ctrl-C (for Copy), Ctrl-V (for Paste). In fact, it is possible that you are conditioned to hear Ctrl-C, Ctrl-V as "Copy, Paste". This is the combination advertised on most Edit menus nowadays (along with Ctrl-X for Cut).

However, coming from a DOS/Unix shell background, I used to find it difficult to press Ctrl-C for Copy because it had negative connotations for me. It used to be (and still is) the keys to press to cancel a running command in a console.

FYI, the same things can be done using
Ctrl-Insert = Copy
Shift-Insert = Paste
Shift-Delete = Cut

I thought this made good sense.
Copy? okay, it's a control insert with no display-change.
Cut? shift into the buffer after deleting it from the display
Paste? Shift out the thing in the buffer and insert it here

Ergonomically, this is in fact better if you do a lot of selecting with the shift-cursor key combinations. You could do everything with your right hand.

So why should it have changed? In this age of GUIs, most people do their selecting with the mouse (with their right hand) and could do the copying/cutting and pasting with their left hand! Personally, I am against selecting stuff with the mouse coz it's more strenuous.

Why Ctrl-C,X,V then? Physical proximity is the only rationale, no logic as in the former case. C for Copy, so get the others nearby.

Or was it because "X" looks like a scissors and you use it to cut! So get the others nearby?

You wish!

Dream Word

2005-08-26T14:53:00.000+05:30

This one is from my archives. Written in July 1997, this article is about what I felt (then) would have been cool features to have in a word-processor. Many have since been implemented and are standard features now. Many of the points are still valid though.

O, LORD PC! COULD I WRITE A LETTER ON YOU? . . . PLEASE!

Auto-Scroller tab

User keeps his mouse on the tab and the document keeps scrolling automatically. User can suspend by moving the mouse away or by pressing, say, Ctrl-V. It is very important to have an alternate key. Pressing another key, say PgUp or PgDn while in auto-scroller could bring another function.

Advanced OLE : Drag and select

User should be able to choose objects and text with a special drag. Maybe the concept of a right-button drag should be introduced.

Make-It-Fit!

Selected text or advanced OLE could be made to fit in a specified number of pages or a region created by special dragging.

Fonts

Super-scripting and sub-scripting should be available easily. Say by pressing a special key combination, say, Ctrl-Alt-F

Toolbars

Rather than themewise arrangement, a global toolbar with most universally and commonly used options should also be there. Themewise arrangement should also be there. Switching of toolbars must be simpler. Also, the program should keep a log of menu-items most used by the user and automatically place them on the toolbar.

Typo-Quikorrect!

Interchanging of letters to form words which do not exist can be easily identified. So why not correct it as well? But before correcting, program should go through the proper authorization channels. Flash it on the status bar whereupon the user can press a key to confirm. If the user does not press the key, he must be allowed to continue typing. No alarm-bells ringing! If the program is so particular that its message be heard, keep it in the error-bin, the user at the end of his session may or may not click the error-bin, a dialog box should open with various errors highlighted. User can then edit out unwanted corrections, press a confirmation key and lo, everything set right.

Equation format

All the word-processors can have a common format for scripting the equation. Type the numbers with codes, like, say, `^= for `raised to= etc. Drag it, block it and presto, encryption disappears and you have a well written equation on your hands. Neat! Wonder why it has not been implemented as of yet.

Menus

Arrangement of menu items should be more coherent and uniform. As far as possible, items common to all the word-processors must be grouped under menus with same or equivalent names.AUniformity by itself is no good.@ Jot it down! It=s a quote and what=s more, it is quotable! The logical arrangement of menu-items is a must-must.

WOFIWOG experience: Eh, what's that?

All in all, a WOFIWOG (What yOu Feel Is What yOu Get) experience is what all of us are searching for. Currently, what we are getting seems to be more of WIFIWYG.You guessed it right! Yes, a What I Feel Is What You Get experience, the I in the acronym standing for the PC and the You for you of course! (Who else? Did I really need to tell you that?) Got that Bill? Thank you!

Heron - Born Flightless?

2005-08-26T14:44:00.000+05:30

The Heron Language is being developed by Christopher Diggins. Heavily influenced by C++. In search of a killer-app...
http://www.heron-language.com/

Some interesting concepts, but syntax seems to be somewhat cryptic with lots of `?' s in the code. The designer's site is at http://www.cdiggins.com/

Behaviour of typeid

2005-08-09T19:08:00.000+05:30

code snippet to illustrate behaviour of typeid


   struct
   {
         int side;
   }square1;

   struct
   {
         int side;
   }square2;


   int main(int argc, char *argv[])
   {
       if(typeid(square1)==typeid(square2))
                        printf("Same.");
       else
       printf("Different.");
   }

oOzone

C++ casts Demystified

Rethink About Reuse

PAPPADOM Framework

Containers: Stick to basic types initially

Schedule Task, View Dependencies

Make It Fast!

Neptuner Coding Guidelines

I Could Have Done It Too

Thomanujan Number - 1229

Baseline Semantics

INTEGRATE – 2008 - Changes done for 2K9

Recipe - Do Something To Each File In Directory

Digital Peer

On Reviews

Perly Gates

Commentstipation

Coding Nirvana - Cryptic Mystic Droppings

Coding Nirvana - Four Noble Truths

C Powershot - Pointers

Looking For A Function

Code Is Prose

Saved By A Unit Test

Unit Test Scripts

Unit Test Environment

Limits Of Unit Diagnosis

Unit Testing As Claim Validation

Unit Testing Primer

Draw The Line

Principles Of Codeline Management

CM Synergy Crash Course

Introduction

Synergy-ese (Essential)

Finding Synergy

Advanced Synergy-ese (Non essential)

Get Out Of Jail Free!

Conclusion?

Root Or Fruit?

Biller - Design Of A Receipt Generator

Design

Receipt

Application

Receipt-Item

Sales-Taxes

Computing the Price of a Receipt-Item

Receipt-Item Creation: Sales-tax policy isolation

Displaying the receipt

Conclusion

Design Assumptions and Choices

Extensibility

Rounding To The Nearest

U3D - Diagramming & Standardization

UML Triple Distilled

SFINAE

Subversion - What can be in a name?

Freeware UML Tool

Degenerate Classes

Decorator Pattern

IsDerivedFrom

Jargon Clash

Advice for language designers

dynamic_cast prerequisite

On The Naming Away - I

Template Friend Functions

Attack Of The Clones

Indirection Is Flexibility

OS Development Resources

T&L - Not Made For Each Other?

Cline's Commandments

ISO C++ updates

Heart For The GNU

On The Hacked Track

Data Polymorphism

INTRODUCTION----------------------------

THE REQUIREMENT--------------------------------

DESIGN WITH BEHAVIOURAL POLYMORPHISM----------------------------------------------------------------------

PERFORMANCE ISSUES...--------------------------------------

...AND A TRIVIAL(?) VIOLATION OF A DESIGN CONSTRAINT------------------------------------------------------------------------

CONCLUSION----------------------

Everything Changes

INTRODUCTION
----------------------------

THE REQUIREMENT
--------------------------------

DESIGN WITH BEHAVIOURAL POLYMORPHISM
----------------------------------------------------------------------

PERFORMANCE ISSUES...
--------------------------------------

...AND A TRIVIAL(?) VIOLATION OF A DESIGN CONSTRAINT
------------------------------------------------------------------------

CONCLUSION
----------------------