Domain Driven Design

Recently read a few sections of the book Domain Driven Design. The importance of understanding the domain is not to be undermined. 

It is not that you can't design/develop without knowing the domain. And not that you could know the domain overnight and design.

Knowing a domain and designing/refactoring is an ongoing process. And the more you know, the more you improvise. 

I, for one, had never given so much of  a thought to domain knowledge, but the examples in the book were really enlightening. I could relate to many of them and also realised that in reality knowing the domain had helped me get many things right in the last 6 yrs!

All and all, the design tips and methodologies in the book are uber cool and helpful too.

Updated: The book: http://www.amazon.com/gp/product/0321125215 

Enabling options based on filetype in vim. Picked from here 

:au BufRead    *.c     so ~/.vim/c.vim
:au BufNewFile *.c     so ~/.vim/c.vim
:au BufRead    *.py    so ~/.vim/py.vim
:au BufNewFile *.py    so ~/.vim/py.vim

Then put this in ~/.vim/c.vim:

set shiftwidth=8 

And this in ~/.vim/py.vim:

set shiftwidth=8 

That'll cause vim to source the specified file when the corresponding file type is read (or when a new file of the corresponding type is created).

Recording some good links

http://www.ddj.com/go-parallel/

http://www.linux-mag.com/cache/7407/1.html

Cilk++

With the advent of 16, 24 (and also 32?) cored machines, multi-core machines are foraying in a big way. Most applications programmed aren't multi-core aware and hence though multi-core hardware prices aren't daunting, the applications can't really scale to it. Redesigning the legacy apps for multi-core aware is not a small task. However suites like Cilk++ do make it so.

Cilk++ comes with a complete suite of compiler, run time system et al, which enables legacy applications that have been designed with no scaling in sight to be multi-core aware with minimal changes. Believe it or not, your code requires as less change as using three keywords effectively to indicate parallelism and synchronization – cilk_for, clik_spawn (for areas which have recursive calls or the types to make use of the multi-cores), cilk_sync (gather results from all the calls). Cilk provides race detector and reducers (race free global variables) as well.

 

To know more, read this:

http://www.cilk.com/multicore-products/cilk-solution-overview/

On using the three keywords to indicate parallelism, the Cilk++ compiler compiles the serial code into multi-core enabled parallel application.

 

N-Queens Problem

A good starting point to understand how this can be used is the N-Queens problem: 

http://www.cilk.com/multicore-blog/bid/6381/Multicore-enabling-the-N-Queens-Problem-Using-Cilk. 

There are other problems discussed as well. You could track the cilk blog to know more.

 

And to know more about the Cilk language itself: 

http://supertech.csail.mit.edu/papers/cilk5.pdf

Python & Scalability

Was checking on Python scalability.

Found some good links
http://highscalability.com/youtube-architecture
http://highscalability.com/tags/python
http://www.python.org/about/success/strakt/ (This one uses Twisted as well)

Generally you can check here: http://www.python.org/about/success/

Couldn't resist this one: http://www.python.org/about/success/rackspace/

And yes, python is not only a scripting language, it is an object oriented programming language too!

A pat for Twisted is here as well:
http://news.zdnet.co.uk/software/0,1000000121,39246546,00.htm

In search for an ORM

Sharan has been searching for an ORM for C++. Though we have been able to find many for Java, python etc; couldn't find one which is popular for C++.

A few that I found, though we yet to evaluate are:
http://soci.sourceforge.net/
http://sourceforge.net/projects/open-orm/
Database Template Library: http://dtemplatelib.sourceforge.net/

Found this one mentioned at a couple of places; but the page just refuses to open up
http://ceamus.com/objbuilder/

If anyone has any better suggestions, let me/sharan know.

wake_me_up or wake_me_not

We had a really tough problem to solve in the last few weeks and we finally got through it.. Every experience of solving a tough problem ends with sweet little learnings. And this time it was about "wake_up" functions on Linux. These functions don't seem to have good documentation anywhere and knowing the nuances of the different variants demands a lot of googling and reading :)
So was quite happy with this find, wherein a person has documented his learnings in one place.

http://groups.google.co.in/group/comp.os.linux.development.system/browse_
thread/thread/607517fcb4ecf29d/d752bf66a0a7bb48?lnk=st&q=wake_up_
interruptible+wake_up_interruptible_all#d752bf66a0a7bb48

And the equivalents of Mac can be found at
http://developer.apple.com/documentation/Darwin/Conceptual/KernelProgramming
/services/chapter_16_section_5.html#//apple_ref/doc/uid/TP30000905-CH219-CHDIDIDF

Hope this will help others in pursuit of wake_up problems!