Saturday, July 18, 2009

Garlic and Herb Chapati

As always, I'm a bit lazy and don't want to spend time baking bread(it is a very long and drawn out process). However I felt like having focaccia(yes the yummy bread with herbs, garlic and loooots of olive oil), so I decided to make a similarly flavoured chapati and see how it turns out.


Whole Wheat Flour:2 cups + more for dusting
Water:Enough to make a really hard dough(we'll soften it up using lots of Olive Oil!!)
Softened Salted Butter:5 Tbsp
The Best Extra Virgin Olive Oil that you can get your hands on and afford:5 Tbsp
Mixed Dried Herbs(Parsley, Basil, Oregano, Rosemary, Thyme):1-2 Tbsp
Salt:1/4 tsp or to taste
Fresh Garlic Paste(it needs to be FRESH!!):of about 10 cloves
An appetite:as much as you can squeeze in!!


  1. Make a very hard dough from the whole wheat flour, water, herbs and garlic paste(take a really deep sniff, close your eyes, and savour the smell for a while).

  2. Use all the Olive Oil and mix it with the dough to make it hard(very hard to hard).

  3. Use this dough to make about 8-10 portions for rolling out.

  4. Keep tava(pan) for heating up on a slow flame. This will ensure that your tava is heated up evenly and your chapati won't get burnt or cooked unevenly.

  5. Roll out the chapati apply dusting flour regularly to prevent it from sticking. Roll out slightly thicker than standard chapatis because we have garlic and herbs in the dough. They may cause the chapati to puncture if we roll it out too thin. If the chapati gets punctured, then it won't balloon like we want it to.

  6. Cook the first size on a slow flame on the tava just until small boils begin to appear on the top surface.

  7. Turn the chapati over and cook on medium flame, turning the chapati so that the sides are cooked well. Always keep the sides in the center of the flame. The center of the chapati will get cooked well automatically. Now, larger boils will appear on the surface, and the under-surface will have brown spots on it.

  8. Make the flame high, remove the chapati from the tava quickly, remove the tava from the stove and turn the chapati up-side-down on the direct flame. Watch it balloon!!!! (if you've done everything well till now. It took me a month and lots of flat chapatis to get to this stage).

  9. Turn it around for just 1 second(or for symmetry as Appu would put it).

  10. Take it off the flame and apply a little of the melted butter while it is still steaming hot.... Smell it again and again till you think you've attained nirvana....

  11. Eat it!!!!

Friday, July 17, 2009


Yet Another Versioning File System....

I've been reading about Versioning and Snapshoting File Systems and here is a mini-dump of what I think so far. Please correct me if I'm mistaken....

I saw a few file systems with slightly more than a cursory glance, and here are my comments:

  1. ext3cow: This is very close to what I have in mind for a versioning and continuous snapshoting file system. However, it does not agree with some of my "requirements of a versioning and continuous snapshoting file system"(below).

  2. Elephant File System: This is probably one of the earlier snapshoting/versioning file systems and has been implemented on BSD. It is modeled on BSD's FFS. It does a great job of doing what it says it does. I like everything about it except that I can't use it on Linux.

  3. NetApp's WAFL: This again is mainly solving a different problem, that of providing very fast and safe storage on a storage appliance. To the best of my knowledge, you need to trigger a snapshot(though the process itself does not take more than a few seconds), and the number of snapshots are restricted to a fixed number(32 or 256). This may be done using hourly cron jobs, etc.... The interface of getting previous versions of files is a little clumsy though.

Requirements of a Versioning and Continuous Snapshoting file system:

  1. It should be able to store a large number of versions of files and directories alike

  2. It should be able to do so very fast and without any user intervention. ie. Snapshoting should not be user-triggered, but should be done automatically on every close()

  3. You should not need to re-compile the kernel to get this functionality

  4. You should be able to apply this to a specific directory root. This means that you should be able to snapshot parts of your directory tree. You should not incur a performance penalty for accessing file out of this region of interest

  5. You should have policies for controlling which file to snapshot and version files based on file attributes such as size, name, MIME type, etc....

  6. The interface for accessing continuous-in-time file versions should be very clean and fairly intuitive, and it should be fairly easy to write tools around it so that GUI/web-based access can be enabled

  7. You should be able to enable this functionality on any file system(and not require to re-format the partition on which you wish to enable it)

  8. You should be able to disable this operation at any point in time and get back to accessing the most recent versions of the versioned files using the earlier access methods without any performance penalty. ie. Users should be able to turn on and off this functionality at will and it should allow users to proof this on real workloads without them having to make any drastic changes in their environments

  9. The operations performed should be safe, and should not result in data corruption

  10. The system should be easy to install and set up

I have in mind something that satisfies the requirements mentioned above....

Tuesday, July 14, 2009

NextGen Storage??

I've been thinking about what storage systems have in store for us in the future. I mean I've been trying to follow the progress of these beasts, and the next big thing I think should be storage devices that have in-built support for some form of transactional memory. Lots of file-system drivers are building consistency mechanisms into their implementation by using logging in some form or the other. This logging is happening on the same medium as the one where data is being stored. A consistent view of the data is formed by looking at (data+log) as a unit of storage.

I think that logging implementations would benefit a great deal if they had some sort of hardware support. For example, NetApp's WAFL is utilizing Flash memory to store it's writes. This I think is a nice way to look at the problem at hand, and if device manufacturers could integrate some of this on to their device using some nice interface, I think that file-systems of the future could be much faster than they presently are.

The only problem that I do however see with this approach is that the flash memory may wear out and cease to function much faster than the magnetic stable storage. A log-based file-system(or storage structure) would be needed to store the writes on the flash storage(something like JFFS maybe).

Crispy Butter Chapati.... yummm....

I have stopped making bread these days because I prefer eating chapatis. They not only take lesser time, but also involve eating a lot lesser flour. Besides, they are thin, can be made crispy easily, and I've been used to eating them for a while. So, I've decided to experiment with different types of chapatis(whole wheat Indian flat-bread). I don't have any pics. of chapatis I've made, but I'm sure google's image search will show up a faithful representation. Or you can visit this wikipedia page about chapatis.

My latest favourite is a layered chapati with layers of butter in between. Yesterday, it was raining quire heavily so our maid decided to spend the night at our place. I was observing her make her chapatis and she made this chapati with oil and flour in the middle, folded it and started rolling again. She was basically layering her chapatis. That's when I remembered that my mother used to feed me something similar as a kid. However, these tasted like run of the mill chapatis, so I decided to innovate and use butter as the separating medium. Believe you me, this adds amazing flavour and taste to the chapati, and it tastes so good that you can eat it as-is!!


Whole Wheat Flour:2 cups + more for dusting
Water:Enough to make a hard dough
Softened Salted Butter:15 Tbsp


  1. Make a hard dough from the whole wheat flour and water.

  2. Use about 1 Tbsp of Butter and mix it with the dough.

  3. Use this dough to make about 8 portions for rolling out.

  4. Keep tava(pan) for heating up on a slow flame. This will ensure that your tava is heated up evenly and your chapati won't get burnt or cooked unevenly.

  5. Roll out cup size and apply butter generously. Apply dusting flour on the buttered side and fold in half.

  6. Repeat the above step one more time to get 2 folds.

  7. Now roll out completely(using dusting whenever necessary) into a chapati.

  8. Cook the first size on a slow flame on the tava just until small boils begin to appear on the top surface.

  9. Turn the chapati over and apply butter on the complete surface generously. Cook well.

  10. Turn it around again, and apply butter on this side now. Cook well.

  11. The more you change sides of the chapati, the more crispy it's surface will get.

  12. Cook till done, and you have achieved the level of crispness that you want.

  13. Eat it!!!!