nXgenesis

8) Computing machines which are variations of PC's like robots, phones, smart phones, gadgets (all above points apply to such machines. And really point number 7 is the one where mobile industry will be going)

9) Categories of applications - Databases, Browsers etc etc.

const or not

2011-04-12T09:08:00.001-07:00

To tell if a variable is const or not, you need to look at the right-most occurrence of the const qualifier (that appears before the variable name). If the right-most const occurs after all other type modifiers (such as pointers), then the variable is const. Otherwise, it is not.

Here are some examples of const declarations :

const char a; // A constant character

char const b; // A constant character (the same)

char *const c; // A constant pointer to a character

const char *const d; // A constant pointer to a constant character

Here is an example of a declaration that is not const:

const char *e; // A pointer to a constant character. The pointer may be modified.

In this case, the pointer e can change---it's only the value being pointed to that is read-only

Python

2011-03-28T09:13:00.001-07:00

http://www.korokithakis.net/tutorials/python

ccache

2011-03-18T09:00:00.001-07:00

http://www.rootninja.com/install-ccache-to-build-code-faster/

Open Source Misc

2010-10-09T19:35:00.000-07:00

List of free and open source software packages on Wikipedia here

Generating SSH key pair

2010-09-16T11:28:00.000-07:00

Generating ssh key pair on MacOS X here

Memory management

2010-07-31T08:21:00.001-07:00

Memory management in different programming languages here

Languages

2010-07-02T08:50:00.000-07:00

Discover Sanskrit here
History of English here

Mac OS

2010-07-01T07:16:00.001-07:00

Programming on Mac OS: Nice Article

Dejal free and useful apps: here

Objective-C in SWIG

2010-07-01T06:59:00.000-07:00

Coming soon. For now, check the Objective C module for SWIG.

Javascript and C++

2010-06-25T07:44:00.000-07:00

http://flusspferd.org/
http://www.cs.unm.edu/~cello/jsgen/

Graphics and Image Processing

2010-06-25T06:32:00.000-07:00

Image Processing Fundamentals Video here
Luminous Landscape here
BRDF models good here
Rendering here

Algorithms and programming

2010-06-25T05:50:00.001-07:00

http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=alg_index
http://www.codechef.com/
http://blog.i.ndigo.com.br/2009/11/the-nature-of-a-programming-language/

Links: Knowledge, business and Innovation

2010-06-24T04:24:00.000-07:00

http://www.ted.com/talks/elizabeth_gilbert_on_genius.html
http://video.google.com/videoplay?docid=1181750045682633998#
http://video.forbes.com/top-shows/breakout
http://www.youtube.com/education?b=400
http://www.howstuffworks.com
http://www.techventuresource.org/
http://www.leadershape.org/resources/books.asp?flash=true
http://www.enterpriseminnesota.org/Magazine-eNewsletter/Enterprise-Minnesota-Magazine/2007-Special/The-Year-in-Tech.aspx
http://www.quickmba.com/entre/
http://www.businessplans.org/directory.html
http://www.socialedge.org/

Programming languages one must learn

2010-06-04T06:15:00.001-07:00

http://www.myelin.co.nz/notes/kent-pitman-languages.html

SWIG Execution model (Taken from SWIG docs)

2010-06-01T05:45:00.000-07:00

An integrated C preprocessor reads a collection of configuration files and the specified interface file into memory. The preprocessor performs the usual functions including macro expansion and file inclusion. However, the preprocessor also performs some transformations of the interface. For instance, #define statements are sometimes transformed into %constant declarations. In addition, information related to file/line number tracking is inserted.
A C/C++ parser reads the preprocessed input and generates a full parse tree of all of the SWIG directives and C declarations found. The parser is responsible for many aspects of the system including renaming, declaration annotation, and template expansion. However, the parser does not produce any output nor does it interact with the target language module as it runs. SWIG is not a one-pass compiler.
A type-checking pass is made. This adjusts all of the C++ typenames to properly handle namespaces, typedefs, nested classes, and other issues related to type scoping.
A semantic pass is made on the parse tree to collect information related to properties of the C++ interface. For example, this pass would determine whether or not a class allows a default constructor.
A code generation pass is made using a specific target language module. This phase is responsible for generating the actual wrapper code. All of SWIG's user-defined modules are invoked during this latter stage of compilation.

Javascript

2010-05-31T06:48:00.000-07:00

Javascript w3schools tutorial
3 ways to define a Javascript class
Classes, Inheritance, Objects in Javascript here, here and here
Object oriented javascript here and here
Javascript passing by value or by reference here
A nice post enlisting major javascript engines.

A little about JavaScriptCore framework

Startup ...

2010-05-04T10:09:00.000-07:00

A cozy Read: Life of a startup-founders-significant-other

How to Install MacOS from DMG

2010-02-25T21:59:00.000-08:00

A very nice tutorial on installing MacOS X from DMG

C/C++ and Linker

2010-02-16T11:41:00.000-08:00

A Beginner's guide to linkers here by David Drysdale.

Object oriented design: Why?

2010-02-11T10:30:00.000-08:00

A great article by David Veeneman on code project.

Wirth's Law

2010-02-11T10:08:00.000-08:00

Wirth's law in computing was made popular by Niklaus Wirth in 1995. The law states:

Software gets slower faster than hardware gets faster

Software is slowing faster than hardware is accelerating.

Hardware is clearly getting faster over time, and some of that development is quantified by Moore's law; Wirth's law points out that this does not imply that work is actually getting done faster. Programs tend to get bigger and more complicated over time, and sometimes programmers even rely on Moore's law to justify writing slow code, thinking that it won't be a problem because the hardware will get faster anyway.

As an example of Wirth's law, one can observe that the time it takes to boot a modern PC with a modern operating system is usually no less than the time it took to boot a PC five or ten years ago.

Changing default header comments in Xcode

2009-11-30T12:30:00.000-08:00

Simple, and easy.... Go to: /Developer/Library/XCode/File Templates and modify the templates.

Lex & Yacc - A Compact Guide!

2009-11-07T21:42:00.001-08:00

Download a compact guide to Lex & Yacc here. Thanks to Tom Niemann at epaperpress.com

Google summer of code, 2009

2009-11-07T14:21:00.000-08:00

My awesome experience with the Google Summer of Code(GSoC) program, 2009 ended recently. I worked with swig, an open source software development tool that connects programs written in C and C++ with a variety of high-level programming languages. The GSoC program is an incredible opportunity for students to work and associate with world class open source organizations. And not to miss, the association with Google - what else you need? Well, you also get one year ACM membership, lucrative stipend, and a cool Google T-Shirt.

It's different experience working on an open source project. Open communication, tremendous support, a 'cool' way to develop software and experienced people around you - people who believe that software like food is more enjoyable when it is available for free. I felt all this while working on swig. Working for swig in the Google Summer of Code program provides an incredible opportunity for students with interest in code generation, programming languages and interoperability. Great support from the project owners - especially William and Olly and not to forget the support you get from mentors like Jan Jezabek. The project is well documented and you get a good support to quick start development.

For the swig GSoC, 2009 project descriptions link here, and my project wiki. The project also finds a mention at Google Open Source Blog here. The branch source can be found here

Swig and the Objective-C support

2009-11-07T14:15:00.000-08:00

I am currently working to add the support for Objective-C as a target language to swig, an open source 'Wrapper and Interface' generator for bridging the gap between C++ and numerous supported languages.

For details of the project, refer to the project wiki. The project source, in early stages of development, is available here

Starting with the web ...

2009-11-06T11:32:00.001-08:00

A good basic mysql tutorial here and here

Article: Apache and the internet

The Apache definitive guide

Link to Web-Designer-Depot
Start with Javascript at w3schools

Maximus ...

2009-11-04T12:50:00.000-08:00

[An article written by Varinder, my friend,. This has got him a Dell laptop in reward from Microsoft :) Posted here, with some tweaking, keep afresh the memories of wonderful time we two have spent together in producing quality software..... ]

Make .NET windows work with C++! It would give users more native looking user interface, and programmers a better platform for rapid application development... seems logical - I thought. I was excited with the overall idea of Maximus - A project which would allow Clients developed in .NET to communicate to and fro with a C++ application. The challenges involved in this endeavor were apparent: Handling of function calls, function pointers, delegates, events from .NET to C++ and vice-versa was a pretty complex task and so was re-using the .NET controls in MFC environment.

After days of exploring, I could only find few solutions: Definition files, PInvoke methods, Extern methods... and certainly I could not find any solution for hosting .NET controls in MFC environment. Though, the existing approaches provided solutions - really? but they seemed non-appealing to me. Why? --- because I did not want to settle for an approach which was not object oriented given our large code base and all of the advantages Object Oriented Programming provides in this regard. A thorough research led to a solution which was simple and flexible and which provided us with the platform to tackle all the above challenges. I followed two approaches for designing a generic interface class, implementing the well know industry set patterns. With this all the above key areas were handled in objective manner. The solution was generic and it provided with an opportunity to develop a Code Generator in Perl which would generate stub class for implementation.

The other challenge was invocation of the .NET windows in MFC environment which was solved by writing a generic library in .NET which perfectly simulates the native palettes/non-dialog window in MFC environment. The approached(s) used are not only a boost for the .NET world, but we have opened many doors for those who are reluctant to code in C, C++ but love to code in .NET. and for all this, the development environment was VS 2005.

Notes: Makefiles

2009-10-20T13:29:00.000-07:00

Why we need Makefiles?
Make program can be called easily from a shell script or a cron job thus we can automate the build process using Make. Instructions for the Make program are stored in a text file which contains commands that must be processed by Make. This file is normally called makefile or Makefile. As a convention, GNU programs named their makefile; Makefile because it is easy to see. If you give it another name, just make sure you include the option –f to make command for e.g.: if you have a makefile named myMakeFile then the command we used to instruct make to process that file is: Make –f myMakeFile
Makefile Structure
A makefile consists of target, dependencies and command(s) section. Dependencies are things or source code needed to make a target, Target is usually an executable or object filename. Commands are needed to make the target. Following is the simple description of the makefile:
Target: dependencies
command
command

Comments comments are put using #
Variables in Makefiles Use variables for short writing and for making future modifications easier.
Defining a Variable: $VAR=value (By convention all uppercase letters are used for variable name)
Using a Variable: $(VAR)
Two kinds of Variables:
(a) Recursively expanded variable
TOP=/home/project
SRC=$(TOP)/SRC
Here SRC is expanded first by expanding TOP. This type of variable is not suitable for the following command
CC=gcc –o
CC=$(CC) –o2
This is an endless loop

(b) Simply expanded variable:
To overcome above problem we can use this kind of variable as
CC: =gcc –o
CC+=$(CC) –o2
A Simple Example
------------mainfile.o ------------mainfile.c
|
|
Myprog ---------
|
|
-------------math.o---------------math.c

Above graph shows the relationship & dependencies among files that are used to make executable Myprog.
If we type “make myprog” at the command prompt; make will walk the above graph to find all the dependencies that have to be changed, then walk back (against the arrows) updating targets until it rebuilds Myprog. Consider the following target present in a makefile.
Myprog: mainfile.o math.o
Cc –o Myprog mainfile.o math.o
When we give the command “make Myprog” following steps are performed in order: mainfile.o and math.o are checked to see if they are up-to-date. If they are up-to-date and Myprog is newer then these files, make will assume that myprogdoesn’t need to be rebuilt. Otherwise it will make sure that each of these files is up-to-date by finding the rules which define their dependencies(go to 4). After 3,make will execute the command on the second line to update Myprog.
More on makefiles
1. Not all targets used by “make” are files to be built. Some are merely named lists of other targets to be built. A common example is the target “all”. This is often the first target in a makefile (because make takes the first target in the makefile as its “default” if no target is specified on the command line) and is usually just a list of dependencies which do the actual file building.
2. Make recognizes each command line by a tab character. The commands within the a rule are executed by make whenever make determines that the target must be rebuilt
3. test: -mkdir ./test
cp myproj test
Placing – sign tells make to continue processing the remaining command lines even if this command line fails.
4. VAR= abc don’t give the space before abc.some make programs will take this as a part of a string.
The command section of a makefile rule may recursively call “make”. In case our project contains sub-directories and a different makefile for each of them. For example if we have
------------------udp
|
Project---------
|
------------------Tcp

And separate makefiles for each of the three folders. Top-level makefile (in project) will be like
all:
(cd Udp; make all)
(cd Tcp; make all)
clean:
(cd Udp; make clean)
(cd Tcp; make clean)

More

For a complete tutorial on Make and makefiles link here

Mico contribution

2009-10-20T13:19:00.000-07:00

My Contribution to Mico here and here

Version Contol and Commands

2009-10-19T11:56:00.000-07:00

Version control with subversion(svn)
Version control with Mercurial
Git for Subversion users here

How to resolve subversion conflicts by Ariejan.

Serial ports communication

2009-09-09T12:14:00.000-07:00

Introduction to serial ports communication: here

Setting PATH on MacOS X

2009-08-31T09:51:00.001-07:00

Simple but sometimes we forget to set path 'permanently' on our MacOS X machine: here is the command: sudo vi /etc/paths

Platform independent Threading in C++

2009-08-13T11:51:00.000-07:00

Nice set of C++ classes for Threads, Mutexes and more. Find here

Auto tools, Automake, Autoconf

2009-08-10T10:01:00.000-07:00

An Introduction to GNU Autotools
Autoconf Macro Index

and the complete doc on Automake

MacOS X ...

2009-08-08T14:07:00.000-07:00

MacOS X system architecture diagram at Apple's site.

Looking for open source packages for MacOS X and iPhone? link here

... and the quintessential MacPorts site

Exception handling in Cocoa

2009-08-01T09:46:00.001-07:00

A great article on exception handling in cocoa.

C++ tutorials

2009-07-31T13:40:00.000-07:00

A good sweet C++ language tutorial by Juan Soulie here

Collection of C++ programming language tutorials by Prof. Douglas C. Schmidt

Function pointers tutorial by Lars Haendel

Callbacks in C++ by Paul Jakubik

A great article on const-correctness in C++

Want to improve your memory?

2009-07-31T12:22:00.000-07:00

Interesting read: Top 10 ways to increase your memory?

Google and Microsoft

2009-07-30T17:31:00.000-07:00

Good read Will Google Destroy Microsoft?

Determining the Vptr address

2009-07-25T22:26:00.000-07:00

The location of Vptr, pointer to the virtual table, for a class with virtual functions, depends upon the compiler implementation. To determine the address of vptr for your compiler, link to devX tip here.

Objective-C , Cocoa, and More

2009-06-24T16:52:00.001-07:00

Checkout this very basic "C" tutorial by Scott Stevenson: here

Short (quick) tutorial for Cocoa programmers:

Very nice Objective-C tutorial by Tristan O’Tierney:

Nice article at linux journal

Apple's Objective-C 2.0 tutorial:

Objective-C wiki

Cocoa wiki

Compiling Objective-C on command line here

Unit testing with Objective C

Easy to understand Memory management in Objective-C

Detecting memory leaks with the Clang static analyzer

Objective-C rest client by Adrian.

Find FAQ on Objective-C here

Last, Google's Objective-C style guide

and Cocoa Style for Objective-C at CocoaDevCentral.

vi editor commands

2009-02-03T09:31:00.000-08:00


Modes
esc             Enter vi Command mode
i               Enter vi Insert mode
a               Enter vi Append mode

Saving, Exiting and Quitting
vi filename     Open file
view filename   Open in read only mode
:wq             Exit vi and save changes
q!              Exit vi without saving changes
:w              Saves the current file without quitting
:e!             Return to last saved version of file
:r              Copies (reads) filename after cursor in file
              currently editing
vi -r filename  Recover a session
:n,yw           Write lines n thru y to new filename

Counts
A number preceding any vi command tells vi to repeat that command that many times.

Moving around in vi
h               Move cursor left one character
j               Move cursor down one line
k               Move cursor up up one line
l               Move cursor right one character
H               Move cursor to 1st line of screen
L               Move cursor to last line of screen
M               Move cursor to middle of screen
CTRL b          Move cursor back one screen
CTRL f          Move cursor forward one screen
^               Move cursor to the 1st char of the line
$               Move cursor to the last char of the line
+               Move cursor to the 1st char of next line
-               Move cursor to the last char of prev line
)               Move cursor to the next sentence
(               Move cursor to the previous sentence
}               Move cursor to the next paragraph
{               Move cursor to the previous paragraph
G               Move to the last line in the file
xG              Move to line x
:#              Move to line #
:$              Move to last line of file

Inserting and Deleting
r               Replace character under cursor with next character typed
R               Keep replacing character until [esc] is hit
i               Insert before cursor
a               Append after cursor
A               Append at end of line
O               Open line above cursor and enter append mode
x               Delete character under cursor
dd              Delete line under cursor
dw              Delete word under cursor
db              Delete word before cursor

Copying and Putting
yy             (yank)'Copies' line which may then be put by the
             p(put)command.Precede with a count for multiple lines.
P               Brings back previous deletion or yank of lines, words, or characters
             before cursor.
p               Brings back previous deletion or yank of lines, words, or characters
             after cursor.

Find Commands
?               Find a word going backwards
/               Find a word going forwards
f               Find a character on the line under the cursor going forward
F               Find a character on the line under the cursor going backwards
t               Find a character on the current line going forward and stop one character before it
T               Find a character on the current line going backward and stop one character before it
;               Repeat last f, F, t, T

Miscellaneous Commands
.               Repeat last command
u               Undoes last command issued
U               Undoes all commands on one line
xp              Deletes first character and inserts after second (swap)
J               Join current line with the next line
^G              Display current line number
set:all         Show all available options
set:nu          Show line numbers
%               If at one parenthesis, will jump to its mate
:.,ns /string// Remove string from cursor's current line to line n
:.,ns /t1/t2/   Replace text with new text from cursor's current line to line n

ex Commands
Any commands form the line editor ex can be issued upon entering line mode. To enter: type ':' To exit: press[return] or [esc].

Links I refer to...

2008-11-17T07:57:00.000-08:00

Mario Konrad Homepage.

Better-Explained

iPhone development

2008-11-17T07:49:00.000-08:00

Some good links to start with the iPhone development:

how-to-get-started?

Memory management in Objective-C/Cocoa/iPhone

Important Unix Commands [from Archives]

2008-02-02T11:05:00.000-08:00

Command Description

adduser Add a new user

arch Print machine architecture

awk Find and Replace text within file(s)

bc An arbitrary precision calculator language

cal Display a calendar

cat Concatenate files and print on the standard output

chdir Change working directory

chgrp Change the group ownership of files

chkconfig Tool for maintaining the /etc/rc[0-6].d directory hierarchy

chmod Change the access permissions of files and directories

chown Change the user and group ownership of files

chroot Change root directory

cksum Print CRC checksum and byte counts

clear Clear terminal screen

cmp Compare two files

comm Compare two sorted files line by line

cp Copy one or more files to another location

cron Daemon to execute scheduled commands

crontab Schedule a command to run at a later time

csplit Split a file into context-determined pieces

cut Divide a file into several parts

date Display or change the date & time

dc Desk Calculator

dd Data Dump - Convert and copy a file

df Display free disk space

diff Display the differences between two files

diff3 Show differences among three files

dir Briefly list directory contents

dircolors Colour setup for `ls'

dirname Convert a full pathname to just a path

du Estimate file space usage

echo Display message on screen

ed A line-oriented text editor (edlin)

egrep Search file(s) for lines that match an extended expression

eject Eject CD-ROM

env Display, set, or remove environment variables

expand Convert tabs to spaces

expr Evaluate expressions

factor Print prime factors

false Do nothing, unsuccessfully

fdformat Low-level format a floppy disk

fdisk Partition table manipulator for Linux

fgrep Search file(s) for lines that match a fixed string

find Search for files that meet a desired criteria

fmt Reformat paragraph text

fold Wrap text to fit a specified width

format Format disks or tapes

free Display memory usage

fsck Filesystem consistency check and repair

Top System and Application Dlls

2008-01-21T05:56:00.000-08:00

Did you encounter the similar message box(es) for your application? or Does it make you wonder why your simple test client is making using of 'this' particular dll? After all, there is plethora of system and application dlls present on your Windows machine.

If answer to any of the above question is Yes ! then do check the link here

The link provides you with the detailed information for almost all of the system and application dlls present or likely to be present on the Windows machine along with the common errors encountered when your machine lacks any of them. I have found this link very handy in my routine programming tasks on Windows. And I think this would be really helpful for any of us - "We - the programmers" !

Rules: virtual base class and more...

2007-11-18T05:06:00.000-08:00

There is more to know about virtual base classes; in addition to the standard c++ rule: virtual base classes are constructed before all non-virtual base classes.

Final Classes in C++ - an incomplete implementation
The following code shows the "incomplete" implementation of final classes in c++ The name Final is taken from Java's terminology for a class which cannot be inherited or derived further. Here is the listing.

class A
{
private:
A() { } // constructor is private, so only friend class can call it.
friend class FinalA;
};

class FinalA: public A
{
public:
FinalA() {} // implicitly calls A's constructor successfully.
};

class Derived : FinalA
{
public:
Derived() {}
};

Before we jump into the explanation, let us make note of another side effect of virtual base classes - the intent for this article.As a c++ programmer you need to know this: virtual base class's constructor is directly invoked by the most-derived class's constructor. I will elucidate this rule with the help of the listing shown above.Here is the play-by-play for above code:

class A's constructor is private so only friend class of A can call it. FinalA is one such class which happens to be a friend class for A and also derives from A. Friend class in fine but why derivation? Ok, the intention here is to suppress the derivation of class A and we intend to achieve this via another class which gets exposed to the user as a Final class. We name this class FinalA indicating that this is a Final class and hence cannot be derived further.

Wait! Are we missing something? ... Ya! ... but before we go for the missing part, try running the following code along with the listing above.

int main()
{
Derived objDerived; //success
}

You should be able to compile and run this program successfully. The only statement in the code creates an object of class Derived. The constructors are called in sequence A(): FinalA(): Derived() or in other words the initialization list for class D invokes the FinalA's constructor first and FinalA's initialization list invokes A's constructor first.

But it isn't the output we want. We want to suppress the derivation of FinalA and for this we want that the compiler should give an error when it encounters the statement: Derived objDerived; Here is how we achieve this.

The "Complete" Final class implementation
Replace the FinalA class declaration with the code below:

class FinalA: virtual public A
{
public:
FinalA() {}
};

The only change we have here is that class A is now the virtual base class for FinalA. Coming back to our earlier note virtual base class's constructor is directly invoked by the most-derived class's constructor; this is one of the special rules a compiler implements so that a virtual base class sub object occurs only once in an instance - the very famous diamond problem.

For our new implementation, A is a virtual base class. This means that the initialization list of class D will now directly invoke A's constructor honoring the rule above. But in our implementation A's constructor is private and only FinalA has the right to access it which means that D has no access to A's constructor. Thus, for the statement, Derived objDerived; compiler will flag an error "A's constructor is not accessible" - the output we wanted for our Final class implementation.

Conclusion
virtual base classes and inheritance offer a set of rules which every c++ programmar should be aware of. Specifically:
virtual base classes are constructed before all non-virtual base classes.
virtual base class's constructor is directly invoked by the most-derived class's constructor.

Mac OS X Leopard unveils...

2007-10-27T02:28:00.000-07:00

Wait for Apple's latest operating System Mac OS X Leopard is finally over. Apple claims it to be the major release in its Mac OS X series with more then 300 new features. Particularly features such as Spaces, Quick Look and improved Finder with an option to browse files with Cover Flow makes it an impressive release. There is lot for developers with Xcode 3.0, XRay and Objective C 2.0. Life goes more better with iLife. Have a look at some of the Leopard features.

Building a Simple Code Generator... Part II

2007-03-05T06:48:00.000-08:00

continued...

The "only" important part
Now, Here is the "only" important part of the article. Complete perl code for our simple generator along with the sample input and the output:

Sample Input

As expained in part I of this article, the sample input for our code generator consists of custom language defined as given below:

<class Name=Sample Access=public>

<function Name=Show Return=void Access=public>

<data Name=var Type=int Access=private>

<data Name=var Type=int Access = private>

</class>

Source Code

Here is the complete "Perl" source code for our simple code generator. This can very easily be extended to form a full fledged code generator for any custom language of choice as input.

#-------------------------------------------
# MAIN ENTRY
#-------------------------------------------
$inFile = "input.txt";

if(! -r $inFile)
{
print "Can not read input file: $inFile\n";
exit 1;
}

%Classes;
&MakeStructures($inFile);
$TargetFolder = "Generated";

if(! -d $TargetFolder)
{
mkdir $TargetFolder;
}

print "Generating html file in in $TargetFolder\n";
&GenCS;

#-------------------------------------------
# SUBROUTINES
#-------------------------------------------

sub TextInterp #2 Interpolate text to output file CURRFILE, stripping leader to |
{
my $lines = $_[0];
$lines =~ s/^\s*\|//gm;
print CURRFILE $lines;
1;
}

sub MakeStructures
{
local ($filename) = @_;
printf STDOUT "Loading $filename\n";
local $state = 0;
local $name = undef;
local $lineno = 0;

# States:
# 0 Looking...
# 1 In Class
# 2 In Function

open FILE, $filename or die "ERROR: Can't open $filename\n";
while($line = )
{
$line =~ s/[<>]//g;
next unless ($line =~ /^class/ or $line =~ /^function/ or $line =~ /^data/);
chop($line);
if($line =~ /^class/)
{
$keyWordString = $';
$keyWordString =~ s/^\s*//;
&MakeClass;
next;
}
elsif($line =~ /^function/)
{
$keyWordString = $';
$keyWordString =~ s/^\s*//;
&MakeFunction;
next;
}
elsif($line =~ /^data/)
{
$keyWordString = $';
$keyWordString =~ s/^\s*//;
&MakeData;
next;
}
else
{
next;
}
}
}

sub MakeClass
{
my %attributes = split /[\s=]/, $keyWordString;
$name = $attributes{Name};
$Classes{$name} = {};
$Classes{$name}{NAME} = $name;
$Classes{$name}{ACCESS} = $attributes{Access};;
$state = 1;
}

sub MakeFunction
{
return if($state != 1);
my %attributes = split /[\s=]/, $keyWordString;
$functionname = $attributes{Name};
if(!defined $Classes{$name}{FUNCTIONS})
{
$Classes{$name}{FUNCTIONS} = {}; # hash of function definitions
}
$Classes{$name}{FUNCTIONS}{$functionname}{NAME} = $attributes{Name};
$Classes{$name}{FUNCTIONS}{$functionname}{RETURN} = $attributes{Return};
$Classes{$name}{FUNCTIONS}{$functionname}{ACCESS} = $attributes{Access};
}

sub MakeData
{
return if($state != 1);
my %attributes = split /[\s=]/, $keyWordString;
$dataname = $attributes{Name};
if(!defined $Classes{$name}{DATA})
{
$Classes{$name}{DATA} = {}; # hash of data definitions
}
$Classes{$name}{DATA}{$dataname}{NAME} = $attributes{Name};
$Classes{$name}{DATA}{$dataname}{TYPE} = $attributes{Type};
$Classes{$name}{DATA}{$dataname}{ACCESS} = $attributes{Access};

}

sub GenCS

{

$temp = $inFile;

$temp =~ s/\.txt/\.cs/g;

print "===== making $TargetFolder/$temp\n";
$CURRFILE = ">$TargetFolder/$temp";

open CURRFILE or die "can't open $CURRFILE\n";
foreach $key (keys %Classes)

{

my $classname = $Classes{$key}{NAME};

my $access = $Classes{$key}{ACCESS};

TextInterp <

$access class $classname

{

EOF

foreach $funct (keys %{$Classes{$key}{FUNCTIONS}})

{

my $functionname = $Classes{$key}{FUNCTIONS}{$funct}{NAME};

my $returnType = $Classes{$key}{FUNCTIONS}{$funct}{RETURN};

my $funcAccess = $Classes{$key}{FUNCTIONS}{$funct}{ACCESS};

TextInterp <

$funcAccess $returnType $functionname();

EOF

}

foreach $data (keys %{$Classes{$key}{DATA}})

{

my $dataname = $Classes{$key}{DATA}{$data}{NAME};

my $type = $Classes{$key}{DATA}{$data}{TYPE};

my $dataaccess = $Classes{$key}{DATA}{$data}{ACCESS};

TextInterp <

$dataaccess $type $dataname;

EOF

}

TextInterp <

}

EOF
}

}

# EOF end of file

Output

Following listing shows the output of the simple code generator for given sample input shown above.As noted for each tag/attribute in the input we have a corresponding C# construct as output.For details refer to part I of this article.

public class Sample

{

public void Show();

int var;

}

Always trust "Copy-Paste"
Coming back, Code generation has one distinct advantage. In today's software world of rapid application development, or as we call it with its new name - agile development, Code Generation techniques provide a way to produce quality code in relatively less time. From writing data entry code to cross-language integration, the mechanical & sought after ctrl-c & ctrl-v method could be replaced by Code Generation with similar benefits.The code produced is ultra consistent - much cleaner and simpler to change. Simply modify the generator and crank out a new version of the source code.In addition, the code produced is relatively less buggy as more of the debugging happens once i.e while developing the generator itself and most important programmers are free to concentrate on the areas of development that deserve their brainpower.

In summary, Code Generation is "Programming for Programmers" and is one of the important techniques a programmer should know as an adjunct to one's skill set. Good Luck !

References
http://www.softwarereality.com/programming/code_generation.jsp

http://www.codegeneration.net/tiki-index.php?page=ModelsIntroduction

Building a Simple Code Generator...Part I

2007-03-04T00:12:00.000-08:00

Microsoft didn't know that a basic feature of "copy & paste" will be the most widely used feature in its operating system. From novel computer users to proficient computer programmers this feature has helped everyone to accomplish their job. I do not support the maxim "Programming is a waste, always trust copy paste" but I am not against it either. Especially “always trust copy paste”. I’ll come to this point at the end of this article. But let's concentrate upon one of the most notoriously famous concept in the software world "Code Generation”. Instead of giving my points on the never ending debate "Code Generation is useful or not?... It's a design smell." I would rather try to give a brief idea of how it can be put into use.

Code Generator
Here is the definition of a Code Generator: A code generator reads your project meta-data and churns out well-formed source code to a specific set of design patterns. In simple words - "A Code generator is a software tool that reads the text from input files, interprets it, arranges the text in desired form and gives us the text output". This "text" could be:
a) The source code written in any programming language: C,C++,C#,Java etc.
b) Code written in any scripting language or markup language HTML, XML etc.
c) Any custom language of choice.
d) ascii/non-ascii text in any natural language

With this intent, Code generation can be thought of as code conversion from one language to another or code rearrangement within the same language.

In developing any Code Generator, there are some basic steps that can serve as guidelines:
a) Recognizing the given source and required output language
b) Recognizing the meta-data and patterns in the source
c) Finalizing the output template or design
d) Choosing the programming language for code generation - parsing and generating - support for string manipulation. Support for containers. Map

I will try to demonstrate these steps with the help of a simple code generator.
This simple generator takes as input a custom defined language as a .txt file, searches for specific patterns in the input text and produces a .cs file -where there is a C# construct corresponding to each pattern in the input language.

Specifically for input such as:

<class Name=Sample Access=public>
<function Name=Show Return=void Access=public>
<data Name=var Type=int Access=private>
</class>

It produces the following C# class as output:

public class Sample
{
public void Show()
{
}
private int var;
}

So here we go:

Analyzing the given source and output language
The first step in writing any code generator is to analyze the input language and output language. Pragmatically, it is not always possible to take any language as input and generate code in any language of choice. For our simple generator, the input language is a custom defined language similar to HTML in representation. Each language tag denotes the beginning of a new programming construct with attributes specifying the properties for that construct. The output language for our code generator is C sharp.

Recognizing the patterns in the input source
The cardinal step in designing a code generator is to recognize the patterns in the input text and required output text. For example, in our custom language, the tag class signifies the beginning of the class specification and the attributes Name and Access specify the properties for this class i.e. specifies a class named Sample with public access. The corresponding class declaration line in C# would be: public class Sample. Noting the patterns in the input and recognizing how a different rendering can lead to the desired output is quintessential in determining the feasibility of the generation. Languages which differ in representation but have identical building blocks can be converted almost completely. On the other hand, for languages, with completely different building blocks, the input text in one language cannot be entirely converted to the output text in output language.For example, our custom language cannot be entirely converted to languages which do not support the concepts of classes (Although some improvisation can almost always be achieved).

Finalizing the output template or design
Before we begin to code for Code Generator, it is imperative to come at the final required Design in the form of a template. With the template in mind, we know which constructs to parse in the input language and at what level of granularity. Given the template for the output, the only job that remains after this is to break the input constructs to a granular level and render or combine the resulting pieces or tokens to match the template. For our generator, the required template is a corresponding C# class declaration for the input class specification.

Writing a Code Generator
Code Generator can be written to essentially perform a sequence of three to four tasks:

1) Define a formal grammar to match the recognized patterns - the patterns to be searched.
2) Parse the input source for our recognized patterns by matching the input text with our grammar i.e determine its grammatical structure with respect to a given formal grammar.
3) Store the matched patterns by breaking them into logical constructs with the required granularity i.e mostly in some intermediate form and with the help of data structures such as lists & maps.
4) Render the intermediate form so that the output conforms to our required template and design.

Choosing the right programming language for writing generator is critically important. The language of choice should provide constructs to help in parsing, constructs for matching patterns & string manipulation and support for containers - lists, maps etc. From the available languages of choice, scripting languages such as Perl, Ruby, Python provide inbuilt support for matching and manipulating patterns. High level programming languages such as C,C++, Java and C# also provide parsing capabilities by giving inbuilt support in the language or in the form of libraries. C++ libraries such as Boost, Regex++ provide good support for parsers and generators. C# has an inbuilt regular expression engine which although is in its nascent stages, provides good support for code generation.

In the second part of this article, I'll provide the implementation details(basically the only important part i.e source code) of our simple code generator using perl as our language of choice.

Continued...

const, volatile and optimization

2007-02-22T06:53:00.000-08:00

Volatile is a type Qualifier which tells the compiler that variable immediately to my left can be changed by factors which are beyond the control of my program.A graphics memory location for example.There is an interesting effect of using volatile on const members which is worth knowing.I tried to explore how using volatile with const can affect compiler optimization. Take an example of another type qualifier const and look at the sample program given below:
int main()
{
int var;

const int const_a = 10;
const int volatile volatile_a = 12;
//Assigning constant to some variable.
var = const_a;
//Assigning a const volatile to some variable.
var = volatile_a;
return 0;
}
I actually ran the code with vc7 and saw the disassembly for the two assignment statements through Visual studio.
1) var = const_a;
2) var = volatile_a;

The disassembler output for these two statements is shown below:

var = const_a;
0041238C mov dword ptr [var],0Ah

var = volatile_a;
00412393 mov eax,dword ptr [volatile_a]
00412396 mov dword ptr [var],eax

If we try to look at the disassembly, In case of first assignment it just moves the value 10(0AH) to the memory location of var. This happens because const_a is a constant variable and its value will not change through out the life time of the process. As an optimization, compiler therefore chooses not to generate load and store instructions for such an assignment. However,In the second statement since we have declared it as volatile,this optimization is not done and instead compiler follows the usual 2 step process for this assignment. i.e it first loads the contents of volatile_a to register eax and then stores the value to the memory location [var].

Interestingly these optimizations happen even in the debug mode(with optimization disabled). So make sure you use volatile only if your variable can be changed beyond your program's control to have the benefit of atleast one microinstruction.

Trick: Un-Sharing the lost Network Folder

2006-12-25T00:16:00.000-08:00

Sometimes on Windows, we confront an annoying situation where we have a shared network folder, we want to Un-Share it, but we are unable to locate the folder on disk. Ofcourse you can go to Computer Management console to get the path from the list of shared folders, But there is another "tricky" way. Suppose you have a shared-folder name “Videos”. You can see it in your network explorer window but cannot locate it on disk. But you want to un-share it. To do this:
1) Simply create a folder with the name “Videos” anywhere on disk and then try to share it.
2) When you click “ok” you will receive an error dialog indicating that share name already exists - with full disk path for the shared folder.

Go. Un-share It!!

Google Error !

2006-11-12T02:02:00.000-08:00

This is how an error with Google looks like :-)

Oops!

Sorry, your web browser is not yet supported.

Our programming wizards tried their darndest to get Google Page Creator to work with as many browsers as possible. But alas, even the most expert practitioners of web sorcery must sleep now and again, lest their JavaScript magic run dry.

So, for now, you'll need either to download a new version of Firefox or download a new version of Internet Explorer (Windows only), and then come right back.

Corba Related links ...

2006-10-28T14:42:00.000-07:00

CORBA FAQ

ORB Basics

AdORB - CORBA ORB for Mac OS X

OMG IDL

Browse Software | OStatic

Re: Corba and Objective C in Windows platform

Linux DCE, CORBA and DCOM Guide

Objective-C GNUstep Base Programming Manual: Objective-C Java and C++

The Free CORBA page

Digital Library

Cetus Links: 18,512 Links on Objects and Components / CORBA ORBs

Exposing CORBA Services as Web Services - Introduction to the Axis2 CORBA Module | WSO2 Oxygen Tank

Web Services/SOAP and CORBA

How to expose a CORBA Service as a Web Service - Application Development Forum

SourceForge.net: StarWebService

Sending pointer types with C structs in a Message based protocol.

2006-10-16T23:14:00.000-07:00

There is an interesting problem in designing a Message-Based(request-response) protocol using C structs.

Problem

Suppose you want to design a message protocol in which the your send/receive functions take void* as parameter, so that you can send and receive C structures that both client and server understand.For example you should be able to marshal the following C-struct as byte array and then retrieve it at the other end:

struct Message

{

char* messageName;

char* messageParams;

};

Problem is that when you use such a structure containg pointers and transmit the struct through Send, then only the memory address stored in the respective variable would be sent, instead ofthe value.Ofcourse, you can use char[XYZ] in place of char* but in that way you could end up passing a lot of memory even when it is not required.

Solution

To tackle this, there is a simple marshalling/demarshalling scheme that takes care of the problem:

1) Since we need to send the data which is variable in size it is appropriate to divide ourmessage body (payload) into two parts.A fixed-part payload followed by a variable part.

2) Basic value types are kept in the fixed part.For pointer types of varied length such as a string or an arraykeep the offset in the fixed part and data in the variable part.This offset can be used for locating the string or array in the variable part of the message. For arrays further,information such as no of elements,type can be kept in the fixed part along with the offset.

3) In this way we end up defining a 2-part message in a buffer of size equal to fixed part plus variable part which can be send using socket api's.

4) A similar unmarshalling procedure will be required at the receiver end for obtaining the appropriate structs from the fixed part and variable part.

The solution provides us with the ability to use pointer types in C structs in our custom protocol.However,you have to take care of byte swapping in case your client,server are on different platforms.

This is taken from my discussion at ITToolbox. Check out the complete thread at
http://c.ittoolbox.com/groups/technical-functional/cpp-l/message-protocol-1139711?cv=expanded

Determining byte order at run time

2006-10-05T01:42:00.000-07:00

Different machine architectures sometimes store multi-byte numbers using different byte orders i.e most-significant first (Big Endian) or least-significant first (Little-Endian). For example, Intel's 80x86 processors and their clones are little endian. Sun's SPARC, Motorola's PowerPC families are all big endian. This difference in byte order can cause problems if a computer unknowingly tries to read binary data written in the opposite format from a shared memory location or file.In order to determine the byte order at run time we can use the following code:

short int mbNumber = 0x0001;
char *byte = (char *) &mbNumber;
if(byte[0])
{
//Little-Endian
}

The private-public-ctor-dtor & virtual tumult

2006-09-15T05:30:00.000-07:00

Here is my first technical blog .This is taken from the document I wrote during my initial days as an ingenuous C++ programmer. This, I think would be really helpful for C++ beginners and may help some prospective job seekers as well. I have done some fine-tuning but the content remains the same. So forgive me for any mistakes you find.I will be glad to hear about any suggestions you have.Please leave a comment and I will update the article in due time.

The tumult
Time to time we often confuse overselves and the interviewers with the ctor, dtor,public, private and virtual errata. Yes I am talking about the constructors, destructors, access specifiers and the virtual keyword when used together.In this article, I will try to explain the different ways in which these keywords affect the object creation of a class.

Basic Setup
For discusion,I have used the basic setup of classes shown below.A is a specification of the class which has an add function, a ctor, a dtor and a friend class declaration. ChildA is the derived class of A and FriendOfA, as the name suggests, is the friend class of class A(i.e it can access it's private members).

class A
{
private:
friend class FriendOfA; //allow FriendOfA to access my private members.
public:
A() {} //ctor
~A() {} //dtor
int add(int a, int b) // a function
{
return a + b;
}
};

class FriendOfA
{
public:
static A* getNewA()
{
return new A(); // creating new object of A
}
};

class ChildA : public A
{
public:
ChildA() {}
};

"virtual" function and the Abstract Class
An Abstract class is one which cannot be instantiated. For making a class A as an abstract class, make one of the functions as pure virtual.This, you can do by declaring a function as virtual with virtual keyword and using a "=0" initializer following the function name. Declaration of such a class(A) goes like:

class A
{
public:
...
virtual int add(int a, int b) = 0;
{
cout <<"Some compilers permit this"; }
...
};

Some compilers will actually permit you to write the defintion body for such a function as in A above, but they will not be called in any case since you are not allowed to create an object of A and being a virtual function you will always be directed to derived class version(The only possible case is to use A:: from inside some function of derived class) Compiler will enforce the abstraction in every possible case here and you will not be able to create an object of the class A either through main or through friend classes, you will however be able to make the objects of the derived classes if they implement every pure virtual function declared in the base class.

class FriendOfA
{
public:
static A* getNewA()
{
return new A(); // error
}
};

class ChildA : public A
{
public:
int add(int a, int b)
{
cout <<"Derived class add function"; }
};

int main()
{
//A objA; // error
//A *pA = new A(); //error
ChildA objChildA; //success
}

This is a true way of making abstract classes.

"virtual"-"Destructor" and the Abstract Class
As above, You can also make the destructor as pure virtual.Using pure virtual destructor for making abstract classes has another advantage. A case when you will prefer to give implementation of a number of functions in the base class itself and/or don't want every derived class to implement a pure virtual function in the base abstract class. In this case, we can make destructor of A as pure virtual. As a result no derived class has a headache of giving any pure virtual implementation because compiler adds the definition of destructors by default. And since our base class A includes a pure virtual dtor, it is abstract as required.This technique can be used to implement the strategy where you want every class to derived from some base abstract class having lot of functionality. Like our object class in C# or java.

"Private"-"Constructor" and the Abstract Class
Another possible solution of preventing object creation for class A is to make its constructor private.Only friend classes will be able to create the objects.You will not be able to make object of A from main directly and moreover you will not be able to create derived class objects.

class A
{
private:
A() {}
...
public:
...
};

class ChildA : public A
{
private:
ChildA() {} // error. A's constructor is not accessible
};

int main()
{
//A objA; // error. A's constructor is not accessible
//A *pA = new A(); // error. A's constructor is not accessible
A *ppA = FriendOfA::getNewA(); // success
}

"Private"-"Destructor" and the Abstract Classes
class A's instantiation can also be suppressed by making its destructor private. You will not be able to create the object(local) of A directly through main.This is because wherever you create A's object compiler will tend to se whether it can destruct it safely.If dtor is private it can't do that so it will flag an error.For the same reason you will not be able to create derived class objects. Note that In this case obviously compiler will not flag error if A is created on heap.But again this would be not be complete. You will not be able to delete this object. Thus deleting pA will give compiler error since delete implicitly calls A's dtor and it is private.

int main()
{
//A objA; // error. A's dtor is not accessible
A *pA = new A(); //success
A *ppA = FriendOfA::getNewA(); // success
//delete pA; // error
//delete ppA; // error
}

You can use this feature for allowing object creation only on dynamic storage i.e heap. Technique most commonly used with smart pointers for refcounted objects. Also see "Preventing object creation on Stack".

"Private"-"Constructor/Destructor" and the Final Classes
You can also use the above two setups for implementing final classes in C++ i.e classes which cannot be inherited. Make ctor/dtor private and then create a class deriving from A(say FinalA) which also happens to be the friend class of A. Since FinalA is a friend class of A. It can call the A's ctor/dtor and hence can be instantiated. Any other class deriving from FinalA cannot call the ctor/dtor and hence cannot be instantiated. This is shown below:

class A
{
private:
~A() { } // Destructor is private, so only friend class can call it.
friend class FinalA;
};
class FinalA: virtual public A
{
public:
~FinalA() {} //implicitly calls A's dtor successfully.
};

class Derived : Final A
{
public:
~Derived() {}
};

int main()
{
FinalA objFinalA; // success
Derived objDerived; // error, A's dtor is not accessible to this Derived class.
}

Private"-"new"/"delete"-Preventing object creation on heap
For preventing creation of class A objects on heap (and allowing just static/local objects), Just give dummy implementation for operator new, new[], delete, delete[] and make them private.It will flag an error during any new statement encountered. You can however, call the global new/delete operators in case you want to allow the creation from friend classes.

class A
{
private:
friend class FriendOfA;
void * operator new(size_t size)
{
return ::operator new(size); // call global operator new
}
void * operator new[](size_t size)
{
return ::operator new[](size); // call global operator new[]
}
void operator delete(void *p)
{
::delete p; // call global operator delete
}
void operator delete[](void *p)
{
::delete[] p; // call global operator delete[]
}
public:
void draw()
{
cout<<"Inside A,draw function"<draw();
}
};

class FriendOfA
{
public:
static A * getNewA()
{
return new A;
}
static void destroyA(A* pA)
{
delete pA;
}
};

int main()
{
//A* pArr = new A[12]; //error
A* pA = FriendOfA::getNewA();
pA->draw();
//delete pA; // error
//delete[] pArr; // error
FriendOfA::destroyA(pA);
return 0;
}
However, there are a number of pros and cons with this implementation which i leave to the reader for self-exploration.

"Private"-"Destructor"-Preventing object creation on Stack
For preventing creation of static or local Objects of class A, make the destructor private. In this way you can create such objects only on heap. Obviously, you won't be able to destroy the object with delete from main. To do so, you have to call some public funtion say destroy which internally calls "delete this". Some guys do not recommend this. But this is ok if you use it judiciously: Make sure you don't make any subsequent call to the object from main after destroy, or call any member function after delete this.

class A
{
private:
~A() {}
...
public:
void destroy()
{
delete this;
}
...
};

int main()
{
//A objA; // error. A's dtor is not accessible
A *pA = new A(); //success
//delete pA; // error
FriendOfA::destroyA(pA); // object of A is dead. don't ! make further calls.
}
This technique along with smart pointers is frequently used in applications for providing Reference Counting mechanism.

Windows: Command shortcuts II

2005-10-28T15:10:00.000-07:00

Microsoft Access access.cpl
Microsoft Chat winchat
Microsoft Excel excel
Microsoft Frontpage frontpg
Microsoft Movie Maker moviemk
Microsoft Paint mspaint
Microsoft Powerpoint powerpnt
Microsoft Word winword
Minesweeper Game winmine
Netmeeting conf
Notepad notepad
On Screen Keyboard osk
Outlook Express msimn
Performance Monitor perfmon
Pinball Game pinball
Power Configuration powercfg.cpl
Printers and Faxes control printers
Printers Folder printers
Registry Editor regedit
Remote Desktop mstsc
Security Center wscui.cpl
Services services.msc
Shared Folders fsmgmt.msc
Shuts Down Windows shutdown
Sounds and Audio mmsys.cpl
Spider Solitare Card Game spider
System Configuration Utility msconfig
System Information msinfo32
System Properties sysdm.cpl
Task Manager taskmgr
TCP Tester tcptest
Telnet Client telnet
User Account Management nusrmgr.cpl
Utility Manager utilman
Windows Address Book wab
Windows Firewall firewall.cpl
Windows Magnifier magnify
Windows Management
Infrastructure wmimgmt.msc
Windows Media Player
Windows Messenger msmsgs
Windows Version
(to show which version of windows) winver
Windows XP Tour Wizard tourstart
Wordpad write

Windows: Command shortcuts I

2005-10-28T14:47:00.000-07:00

Add/Remove Programs appwiz.cpl
Administrative Tools control admintools
Adobe Photoshop photoshop
Automatic Updates wuaucpl.cpl
Bluetooth Transfer Wizard fsquirt
Calculator calc
Character Map charmap
Check Disk Utility chkdsk
Clipboard Viewer clipbrd
Command Prompt cmd
Computer Management compmgmt.msc
Control Panel control
Date and Time Properties timedate.cpl
Device Manager devmgmt.msc
Disk Cleanup Utility cleanmgr
Disk Defragment dfrg.msc
Disk Management diskmgmt.msc
Disk Partition Manager diskpart
Display Properties control desktop
Display Properties desk.cpl
Driver Verifier Utility verifier
Findfast findfast.cpl
Firefox firefox
Folders Properties control folders
Fonts control fonts
Fonts Folder fonts
Free Cell Card Game freecell
Hearts Card Game mshearts
Help and Support helpctr
Internet Explorer iexplore
Internet Properties inetcpl.cpl
IP Configuration ipconfig
Java Control Panel javaws
Logs You Out Of Windows logoff