sizeof(uint32t)

Learning about Bitcoin or why I'll never use Bitcoin

noreply@blogger.com (Sohail Somani) — Sun, 29 May 2011 21:13:00 +0000

Bitcoin is quite a promising e-currency. Created by some-guy-we-don't-really-know-or-a-double-agent-of-some-kind-who-is-probably-quite-Bitcoin-rich-now, it has some very useful properties:

Creation of the money is an implicit and transparent agreement between users. That is, there is no centralized issuing authority and there is a finite quantity. Almost like gold.
It is completely electronic and therefore very cheap to transfer. As a result, transaction fees are "low".
Transactions are anonymized, yet completely public to avoid against double-spending.
Some crypto stuff to make sure it is as secure as it can be today

The main desired outcome of a currency with these rules is autonomy of the currency from the somewhat arbitrary influence of centralized planners.

How you are supposed to use Bitcoin

So how do you use Bitcoin (BTC) as a consumer or vendor? Let us assume that you already have some BTC in your account.

Visit place of business
Locate item of interest which costs 0.02 BTC
Go to cashier
Pull out smart phone with your Bitcoin wallet or some kind of link to your Bitcoin wallet
Use QR-code at register to find vendor's payment address. This address will likely be generated at the point of purchase
Send Bitcoin to that address from your Bitcoin wallet
The cashier and network verifies your payment (speed depends on transaction fee) and you go on your way

This is how it would work today if a business accepted BTC. I expect that if I am wrong and if Bitcoin does indeed take off, there will be clearing houses to speed up transactions like these. I think that these confirmations will necessarily be done outside the network but eventually, the network will also validate these which will be the final settlement step.

This exchange is appealing for various reasons. My favourite one is that the users of the system itself benefit by confirming transactions. That is, you can make Bitcoin just by verifying transactions.

Bitcoin Wallet

It is probably useful to discuss where Bitcoins are stored. This location, a file on your hard disk, is called a wallet. It consists of a set of private keys that correspond to each address generated as in the above scenario. This is your vault. If it is stolen in unencrypted form, your money is probably as as good as gone. But the coolest part is that if you have a backup and it was encrypted, you simply transfer the money to an account in a new wallet before the thieves are able to crack the encryption and almost by magic, your money is back again.

Anonymous vs Anonymized

Earlier, I said that transactions are anonymized. This is different from them being anonymous because an anonymizing technology does not imply anonymity. A transaction being anonymous means untraceable which is something that is quite easy to disprove in the BTC world.

Let's start at the beginning. How do you get BTC? There are a couple of ways. One way involves a lot of geekery and stuff that very few people have time for. This is called Bitcoin mining. For most people, just outright buying BTC like they buy USD is the most convenient. Currency is a proxy for labour so it is fine to buy BTC. As the market will continue to be volatile due to the simultaneous debasing of the USD, demand-side pressure as well as the continuous creation of BTC, I would spread out bigger purchases over a few months.

A convenient way to buy BTC is through an exchange. So let us walk through that process:

Create an account with a BTC exchange. I used Bitcoin Market. This requires you to give them two things: an email address and a Bitcoin payment address. Notice how your email address is tied to your BTC address.
Figure out the trade you want to make. I used BMBTC for PPUSD where BM = Bitcoin Market and PP = PayPal.
Execute the trade by making a payment to some email address on PayPal.

When I executed this process, it took a total of 15 minutes for the trade to complete but it was a full hour before the money was in my actual wallet and verified by the network. You must note that this is the equivalent of someone on the other side of the world paying me $10 and someone delivering that $10 to me personally. Not to a bank account, not a promise for $10, but cold hard cash to me personally.

Notice that the process of conveniently buying BTC itself has multiple weak links:

Your email address is tied to a Bitcoin address by Bitcoin Market
Paypal knows who you are definitively through the use of your credit card
Some random dude knows you bought some BTC

To avoid leaking too much information, you can create a new receiving address for every trade and update it on the Bitcoin Market. Note that Bitcoin Market has full trade information and PayPal has amount information. To reduce the risk there, you can use anonymizing email services or a special email just for Bitcoin purchases.

The main point is that once you use a credit card or a personal email address, your anonymity is compromised.

That's not such a big deal, to be honest. After all, you already trust a lot of people with your information online.

De-anonymizing the transactions

If the seller of the BTC was interested in which address bought the BTC through the exchange, s/he would just track the blocks for the specific amount.

When I purchased my BTC, I chose 2 BTC to see how difficult it would be to find in the block explorer. It was pretty easy! Why? Because I knew there would be three related transactions: one for 2, one for 1.99 and one for 0.01 (transaction fee by exchange.) The seller would know this as well.

So all I did was wait for a few blocks to come through the explorer and opened them all up in a browser tab and searched for 1.99. It took less than a minute.

So now, the seller of the BTC has tied my name (through Paypal) to an address.

You may be interested in the actual transaction as currently being confirmed by computers worldwide. Because of this decentralized confirmation, it is now impossible for the seller to re-sell the same BTC to someone else.

Using my Bitcoin or why I'll never use it

Can you figure out what I did with my BTC? Actually, you have all the information you need in this blog post. Once you figure it out, you'll understand why I'll never use it. The first person to add a comment with the right answer and their Bitcoin receiving address will get the remainder of my balance transferred to their Bitcoin address. It's not much, but I probably won't use it...

How to stay anonymous

There are ways to stay anonymous by obfuscating the block chain. However, this is not right. For a currency to be useful, its primitive form must be practically anonymous and not just anonymizing.

How I'd change Bitcoin

My main issues with Bitcoin:

Not anonymous: Identity "anchors" are very easy to establish by transacting with people as described above. This leads to a situation where an attacker can find out what you spend your BTC on for their own nefarious purposes.
The currency has no decay value. That is, it can be hoarded without consequence. I would like BTC to expire so that the currency can keep circulating. This maintains the value of the currency but prevents hoarding. The block chain has enough information to do this. Miners should be interested in this because it means they can continue to mine forever and keep a healthy Bitcoin economy.

I think the anonymity problem is the most hard to solve. I am only concerned with the ability to transfer coin between my own accounts easily without notifying anyone else. If some way could be devised to solve these problems, goodbye centralized currencies.

Deconstructing a dependency injection-driven application

noreply@blogger.com (Sohail Somani) — Wed, 27 Apr 2011 00:13:00 +0000

I've been using my C++ dependency injection library for a project in the last year and it's gone pretty well. There are a lot of rough edges but I thought it could be interesting to the 3 of you still subscribed to this blog to de-construct the stock quote application.

About the application

The example itself is pretty straight forward. You have a choice of 3 stock quote providers: Yahoo!, static and phone. You choose one and ask for a stock quote. Magic happens and your stock quote arrives.

Example session (with some debug output)

Welcome to the DI Stock Quote App. Simplifying and complicating software development since 2010.
Which stock quote service would you like to use?
1: static
2: phone
3: yahoo
Enter your choice (1-3) and press enter: 3
You chose: yahoo
[DICPP]: No scope constructing: di::type_key<YahooStockQuoteService, void>
[DICPP]: Constructing: di::type_key<di::typed_provider<HttpDownloadService>, void>
[DICPP]: Completed constructing: di::type_key<di::typed_provider<HttpDownloadService>, void> with address: 0x100750
Stock symbol (type quit to quit): goog
[DICPP]: No scope constructing: di::type_key<HttpDownloadService, void>
[DICPP]: Constructing: di::type_key<boost::asio::io_service, void>
[DICPP]: Singleton: constructing: di::type_key<boost::asio::io_service, void>
[DICPP]: Completed constructing: di::type_key<boost::asio::io_service, void> with address: 0x1008a0
Current price for goog: 532.82
Stock symbol (type quit to quit): quit

See how the construction of the HTTP service is automatically delayed until actually needed. This is done through a concept called a "provider" which is basically an automatically generated factory.

About Dependency Injection

A really good introduction to the dependency injection technique as implemented by Guice can be found here. It's probably one of my favourite tech talks of all time.

Anyway, to refresh your memory, here are some of the main benefits of the technique used in Guice:

Object construction and lifecycle management is mostly handled for you.
Less boilerplate.
Makes code more testable.
Scopes (~object creation/lifecycle) can be customized by the user.

In short: a lot of the time, you no longer need to allocate objects or pass some object unused down multiple layers of functions or object constructors just to use them once way deep down in some code.

Magic!

I don't really recall how it is done in Guice but in the C++ library linked above, this magic is driven by a type registry which recursively registers constructor arguments as well as user customizations.

In extreme cases, you can initialize an entire application with a few lines of code:

  di::registry r;
  r.add( r.type<MyApplication>() );
  r.construct<shared_ptr<MyApplication>>()->execute();

This constructs the type registry which is a kind of factory. There is a mini-DSL for describing how you want the registry to handle the type. More on this later. In this case, we are asking the registry to "learn" about the MyApplication type as well as all objects that are required for constructing MyApplication.

"Pish-posh", you say. "MyApplication has a 0-arg constructor. I could do that in my sleep."

Would you be surprised if I said that the MyApplication type actually has 3 arguments?

Well, the above is almost what the StockQuote application looks like. Here is the main function for the stock quote example:

di::injector inj;
inj.install( StockQuoteAppModule() );

StockQuoteApp & app = inj.construct<StockQutoeApp&>(); // lifetime
app.execute();

And here is the constructor for the StockQuoteApp type:

DI_CONSTRUCTOR ( StockQuoteApp ,
                ( boost :: shared_ptr < UserInterface >  ui , 
                 boost :: shared_ptr < StockQuoteServiceFactory >  factory ));

When we ask the "injector" to construct the StockQuoteApp instance, it automatically creates the UserInterface as well as the StockQuoteServiceFactory instance.

The di::injector type is just a thin wrapper around the registry so you can treat it as such. The only thing it really provides is a little bit of syntax to allow you to create modules in a similar manner as Guice. The guts of StockQuoteAppModule accept a registry as a parameter and register the various types. You can see the mini-DSL referred to earlier:

void
StockQuoteAppModule::operator()( di::registry & r ) const
{
  // In each module we define the module's root objects, in this case,
  // StockQuoteApp as well as implementations/specializations of any
  // abstract classes. For example, UserInterface is an ABC and we choose
  // the console-based UI here.

  r.add(
    r.type<StockQuoteApp>()
    .in_scope<di::scopes::singleton>() // The reason we can request a reference in the main function!
    );

  r.add(
    r.type<UserInterface>()
    .implementation<ConsoleInterface>()
    .in_scope<di::scopes::singleton>()
    );

  r.add(
    r.type<StockQuoteServiceFactory>()
    .implementation<StaticStockQuoteServiceFactory>()
    .in_scope<di::scopes::singleton>()
    );

  r.add(
    r.type<HttpDownloadService>()
    .implementation<AsioHttpDownloadService>()
    );

  r.add(
    r.type<boost::asio::io_service>()
    .in_scope<di::scopes::singleton>()
    );
}

As you can see, the mini-DSL (ugly, ugly, ugly, details) describes a few things:

Default implementations for various interface classes. See UserInterface and ConsoleInterface, for example.
Life-cycle management. Singleton is mostly used here but you can also have HTTP-session scopes, thread-local scopes or no scopes (as in HttpDownloadService).

What this means is wherever a type T with a DI_CONSTRUCTOR macro is registered, the registry will use these rules described by the DSL to construct any arguments to T.

Providers
In this library, there is a concept of a type called a provider whose sole responsibility it is to construct objects (usually within the constraints of a scope). In the app session above, I pointed out how the HTTP download service is not instantiated until it is actually needed. This is done via a provider. You can see the YahooStockQuoteService has a constructor which accepts a provider and a function which makes use of it.

That should be enough information to peruse the example itself. Check the README as there are a couple of interesting exercises you can try.

By the way, this requires a Boost checkout with a built version of Boost Build. I apologize if you can't get it to build on checkout, but I haven't really focused on having other people use it!

Comments and thoughts welcome.

C++ has not jumped the shark

noreply@blogger.com (Sohail Somani) — Tue, 29 Mar 2011 15:55:00 +0000

I love John's blog. If you are not subscribed, you should be subscribed. He is one of my favourite bloggers as I actually learn something when he posts.

Somehow, I managed to miss his post on C++ going about as far as it can go in its evolution. Fortunately, it showed up on YCombinator News a few days back so I got the chance to catch up.

From my reading, John is concerned about the following:

The language has stopped evolving because it is too long between revisions of the standard.
He doesn't need anything new therefore new features are not useful for him.
Something about concepts.

I don't intend on refuting or accepting those points as that's not what this is about. I just wanted to give a short summary. Also, I'm not really that interested in concepts but that is no reason to not include them. I'm sure I would also have said "TEMPLATES? WHY DO WE NEED THIS COMPLEXITY?!!!!"

The current C++ standard has been greatly influenced by the various Boost libraries. From lambda to thread, the influence of the Boost development experience is obvious, if not prevalent. Boost made it easy to decide what libraries to include. After all, we've had a few years of practical experience with them.

Reading the list of libraries in first-released order, there are a lot of libraries for various holes in the standard library. The Wikipedia article on the Boost libraries makes it much more clear as to where Boost development has been focused.

There is another trend: the number of libraries dealing with language issues has steadily decreased over time. Now, that is not to say that there will not be another set of C++0B libraries, there probably will. But I don't know if it will trigger the same kind of innovation.

So if that is all true, is C++ over?

In the last few years, there has been a gigantic evolution in C++-land: Clang. I have been fortunate enough to spend some quality time with Clang in the last little while and I have to say that I have enjoyed it a lot more than the last time I spent some time with another open-source C++ compiler.

With Clang, it is reasonably easy to add new features, even easier to add features that translate into combinations of existing features.

So while it was straightforward to add library changes to C++0B due to Boost, it was a lot harder to do the same for language syntax because there was no real experience with many of the proposed features.

Clang can enable, for the language, what Boost enabled for libraries.

However, I don't think Clang is really at the point from an organizational and technical perspective where it can enable and manage the kind of innovation that Boost was able to oversee.

That being said, I look forward to its role in the future of C++. I think it's a bright one*.

* Someone please make C++0B lambda polymorphic.

Continuous testing with Emacs

noreply@blogger.com (Sohail Somani) — Sun, 15 Aug 2010 18:32:00 +0000

The other day, I came across a very interesting paper on continuous testing during development. In it, the authors found that program correctness for a group of students could be predicted based on whether the students used continuous or manual testing. Continuous testing is running your compilation and project tests as you save files locally, as opposed to continuous integration which usually works as you check in code. Manual testing is having the student run the test suite manually. Those students who used continuous testing were a few times more likely to finish the project and had less mistakes.

There is nothing in Emacs preventing a developer for implementing this behaviour for their projects so I decided to do that to simplify the edit-test cycle for a particular project.

The key is that after saving a file, using the built-in Emacs hooks, I launch a compile process. The hook only does so if the file being saved is located in the project directory by looking for a string in the filename, "tmp" in this case.

Here is a screencast of the behaviour with the code in the left side of the split. In the right split, I am editing a script (/tmp/runtest) which represents the test suite. The "project" is located in /tmp. The video shows me saving the test suite file twice. Once with no errors and the second time with an error. In the first case, the compilation buffer goes away once the test suite has run, which keeps things tidy. In the second case, the compilation buffer stays around because an error occurred in the "test suite".

This specific setup works best with a compilation and test phase which runs relatively fast. To make it work for longer test suites, you'd need to probably modify the test-command code to kill the compilation first. You'd probably also want to modify the after-save-hook to use some kind of timer after which you start the compile.

There are lots of things which I'd like to work better, but it works OK for me now.

Let me know how it works out for you if you try it out. The code is here.

Enjoy!

Dependency Injection in C++/Plugin-based C++ applications

noreply@blogger.com (Sohail Somani) — Sat, 22 May 2010 18:22:00 +0000

I have made two of my coding research projects available on bitbucket. One is an example of writing a C++ application which can dynamically load and execute Python plugins and the other is an investigation into a Google Guice inspired dependency injection library in C++.

See the wikis for some explanation and browse the code. The code is under WTFPL.

If you're wondering, I chose Mercurial because I do not have the brain capacity to understand Git.

Using Boost Build on your own projects

noreply@blogger.com (Sohail Somani) — Mon, 21 Dec 2009 01:13:00 +0000

While I am a fan of SCons, every now and then I like to dabble in other build systems. One that has intrigued me for some time is Boost Build (BB). You can visit the linked site to find out more about it but in a nutshell, it is a very elegant way to build C++ software.

This post will attempt to give you some steps you can use to get started using the tool on your own projects. Note that it is a bit long but if you are new to Boost Jam as I was a few weeks back, I think it might help you get started. Please feel free to ask any clarifying questions in the comments.

In the following Boost Jam is the build tool and Boost Build is the library on top of the Jam language. I use them interchangeably, and I'm sure people will give me hell for it.

Building Boost Jam

Before getting started, I suggest you build Boost Jam as follows (might as well get Boost too!). I assume you are on a Unix system ~~because there really is no reason to use Windows anymore ;-)~~ but you should be able to get the same results on Windows with some slight modifications.

$ wget http://downloads.sourceforge.net/project/boost/boost/1.41.0/boost_1_41_0.tar.bz2
$ tar -xjf boost_1_41_0.tar.bz2
$ pushd boost_1_41_0
$ export BOOST_ROOT=$PWD
$ pushd tools/jam/src/
$ ./build.sh
$ export PATH=$PWD/bin.macosxx86:$PATH # substitute appropriately

Now, when you type "bjam" at the command prompt, you may get the following output:

$ bjam
warning: No toolsets are configured.
warning: Configuring default toolset "gcc".
warning: If the default is wrong, your build may not work correctly.
warning: Use the "toolset=xxxxx" option to override our guess.
warning: For more configuration options, please consult
warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html

error: error: no Jamfile in current directory found, and no target references specified.

The Jam Language

One complaint about Boost Build is that we must use the Jam language. However, it's really not so bad. While I would prefer Python, the Jam language is consistent and very simple. The main things to remember (this is my mental model and may not be technically accurate):

Rules are the same as functions in other languages

Parameters to functions are separated by ":"

All tokens are white space separated (use quotes to embed white space)

Results of functions can be used by enclosing the function call in a [] pair

Comments start with # and go to the end of the line

Here is an extremely simple example of a rule/function (create a file called "Jamroot" in the current directory and put in the following):

rule show-list ( list-of-stuff + : sep ) #1
{
    for local l in $(list-of-stuff) #2
    {
        echo $(l) $(sep) ; #3
    }
    return "Hello, World" ;
}

echo [ show-list 1 2 3 : "|" ] ; #4

This line declares a new rule called "show-list" which accepts two parameters: a list as the first parameter and a single value as the second. Note the "+" modifier on the first parameter. This indicates to the build tool that at least one parameter is expected. You can use "*" to indicate 0 or more. I believe this can also be used to indicate optional parameters

This line is a for loop using a local variable. Note the variable expansion using the "$()" syntax. In this case, each iteration of the loop will expand to an element of the list in list-of-stuff.

Here we call the echo rule. Note that the line is terminated by the ";" symbol. This is required!

Finally, we call the new rule with a list as the first parameter and a keyword enclosed in quotes as the second parameter. We use the result of that rule and pass it to echo.

If you execute "bjam", the output looks something like:

1 |
2 |
3 |
Hello, World

Pretty boring!

Creating a new project

When Boost Jam is invoked, it looks for a file called "Jamroot" in the current directory or in one of the parents of the current directory. This is where you define project global settings. Let's do that now. Create a new file called Jamroot and include the following contents:

import toolset ;

project app
  : requirements
    <threading>multi
    <link>static
    <warnings>all
    <warnings-as-errors>on
    # Equivalent to <toolset>darwin: <architecture>x86 <toolset>darwin: <address-model>32
    [ conditional <toolset>darwin: <architecture>x86 <address-model>32 ]

  : default-build debug release
  : build-dir build
;

The requirements state that all artifacts should be built using multi-threaded libraries, built statically with all warnings and all errors. Additionally, on darwin, we only want to build 32-bit executables for the x86 architecture.

In the default build (when you type just bjam), both debug and release variants will be built and put into the build directory relative to the Jamroot.

Now, type "bjam". If you are on OSX, you may see something like the following:

$ bjam
warning: No toolsets are configured.
warning: Configuring default toolset "gcc".
warning: If the default is wrong, your build may not work correctly.
warning: Use the "toolset=xxxxx" option to override our guess.
warning: For more configuration options, please consult
warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html
...found 1 target...

The reason for this is that BB guesses the toolset but on OSX we should really be using the darwin toolset. When Boost Jam starts up, it looks at ~/user-config.jam (somewhere similar on Windows) for a user configuration file. Add one with the following contents:

# ~/user-config.jam
using darwin ;

Now when you hit bjam, you should see something like:

$ bjam
...found 1 target...

Alternatively, if you don't want to pollute your file system, you can execute:

$ bjam toolset=darwin
...found 1 target...

Adding a project target

Now we will add a simple executable that links to some Boost libraries. Create a directory named "app" in your current directory and create a file in this directory named "Jamfile" with the following contents:

# app/Jamfile
exe app : [ glob *.cpp ] ;

Additionally, create a C++ file in the app directory with a trivial main function and the ".cpp" extension. Execute bjam. Nothing changed! That's because we haven't asked BJam to build our project. Try executing "bjam app". You should see something like the following:

$ bjam toolset=darwin app
...found 20 targets...
...updating 17 targets...
common.mkdir build
common.mkdir build/app
common.mkdir build/app/darwin-4.0.1
....
darwin.compile.c++ build/app/darwin-4.0.1/debug/address-model-32/architecture-x86/link-static/threading-multi/main.o
darwin.link build/app/darwin-4.0.1/debug/address-model-32/architecture-x86/link-static/threading-multi/app
common.mkdir build/app/darwin-4.0.1/release
...
darwin.compile.c++ build/app/darwin-4.0.1/release/address-model-32/architecture-x86/link-static/threading-multi/main.o
darwin.link build/app/darwin-4.0.1/release/address-model-32/architecture-x86/link-static/threading-multi/app
...updated 17 targets...

Note that both debug and release builds were created with one invocation. To restrict to one or the other, execute "bjam variant=debug" or "bjam variant=release".

Using Boost

Remember when we downloaded Boost? Now we will use it! The mechanism for using another Boost Jam project is the "use-project" rule. Add the following to your Jamroot file:

use-project /boost : ../boost_1_41_0 ;
alias boost_thread
: /boost/thread//boost_thread
: <warnings-as-errors>>off # bunch of warnings

Here we told the build system where the project with the id "/boost" is located. In this case, it is ../boost_1_41_0, relative to the Jamroot file. Yours might be different. Additionally, we added an alias for the Boost thread library. The main reason for this is that a single alias reduces proliferation of any special handling needed.

If you type "bjam" now, you will not be surprised that nothing is being built. Let's fix that now. Add the following to the Jamroot file:

build-project app ;

Now, whenever you invoke bjam, the app project will always be built. Invoke bjam now. You should notice that Boost thread is not being built. Again, this is not surprising. We aren't using it anywhere! Modify app/Jamfile to look like the following and execute bjam:

exe app : [ glob *.cpp ] ..//boost_thread ;

You will notice that Boost thread is being built in the Boost directory. This is not very useful as build artifacts are spread all over your disk. (Un?)Fortunately, there is a hack to making this work. Create a new file at the level of your Jamroot named "boost-build.jam". Fill it with the following contents:

# Add --build-dir to command line so that boost Jamfiles pick it up and use this directory to build.

ARGV += --build-dir=build ;

BOOST_ROOT = vendor/boost ;
BOOST_BUILD = $(BOOST_ROOT)/tools/build/v2 ;
boost-build $(BOOST_BUILD) ;

Boost Build looks for this file when building Boost (I think) so here we add the --build-dir parameter so that when building boost, it will build to our build directory. That's a lotta building ;-)

Hit "bjam" now. You should see Boost thread being built statically in the build directory now, in both debug and release variants.

Conclusion

In this post, you learned how to build Boost Jam, a little bit about the Jam language and created a simple project utilizing the Boost libraries. Next time, I will build on this post to cover making a plugin-aware C++ application (this is really quite exciting for me!) Again, if you have any question or comments, feel free to leave them below.

Knowing when to quit

noreply@blogger.com (Sohail Somani) — Sun, 29 Nov 2009 20:37:00 +0000

"Crossing the Chasm" and "The Dip" are both great books which talk about a distinguishable lag between when early adopters and the bulk of your target market start paying attention to you, financially anyway.

There is a problem though: a failure and such a chasm look exactly the same for a fairly long time.

I think a second problem which I'm not sure any book really addresses is that some think they are in a dip when in fact they never entered a dip to begin with. That is why you hear things like "You can't give up now, you made $200!" because they assume that every market is infinitely sized and you've just got to keep going!

I read somewhere that the average annual sales for shareware is $400. Enough of those and the payment processor is doing alright but of course the authors are not. Classic case of middle-man makes the most money in a transaction.

So if you are one of those $400/year authors and you need to spend more than 2 hours a year on maintenance, I would really think that is a good reason to quit and do something else. You're not going to miss the $400. You never entered a dip.

There is a very popular and article titled Shareware Amateurs vs Shareware Professionals. I highly recommend a read. Almost as a case-in-point, the author of that article has quit software altogether and is a fairly successful blogger. That is knowing when to quit.

If you have to quit, which I do advocate in the right circumstances, it does not mean you are giving up. You are just going to keep trying until you hit your mark. And for heaven's sake, don't think of yourself as a failure. A failure is someone who never tries.

What do you think?

Using Boost Function with Qt, Part 2.

noreply@blogger.com (Sohail Somani) — Sat, 17 Oct 2009 14:09:00 +0000

[Following up this post]

Johan asks:

please, please post that follow-up. I'm new to Qt and have just run into this problem. While searching the net, I think your solution seems like the best approach!

Who am I to deny a seeker of knowledge? Having used this method in a couple of projects now, I think it is fairly sound and easy to maintain. So here goes.
The main problem with the solution outlined in the earlier post was that it could not handle multiple arguments. On that same post, Ken posted his solution apparently inspired by mine. His solution also handles multiple arguments but does it by implementing qt_metacall, i.e., mimicking moc. This is probably the most scalable solution and I'll probably give it a second look when I need to do this again. The only problem might be requiring exact matches for types but I am not sure how much of an issue this is for code I have written.

To review, the problem is that we want to use function objects (Boost Bind, Boost Function, etc) as Qt slots because sometimes it is too much work to create stateful slots.

My solution looked something like this:


struct SignalHandler0 : QObject
{
private:
Q_OBJECT
public:
SignalHandler0(QObject * parent,
              boost::function const & f):
 QObject(parent), // parent will delete this object when destructed
 m_f(f) {}

public slots:
void
handleSignal()
{
 try
 {
   m_f();
 }
 catch(...)
 {
   // Cannot throw exceptions from signals.
   ASSERT_BUG_HERE
 }
}
private:
boost::function m_f;
};

bool
connect(QObject * sender, const char * signal,
     boost::function const & f)
{
return QObject::connect(sender,signal,
                       // Note: Not a leak as sender will delete the handler when destructed
                       new SignalHandler0(sender,f),SLOT(handleSignal()));
}

To extend it to a single argument, we might do:

struct SignalHandler1 : QObject
{
private:
Q_OBJECT
public:
SignalHandler1(QObject * parent,
              boost::function const & f):
 QObject(parent), // parent will delete this object when destructed
 m_f(f) {}

public slots:
void
handleSignal(QString const & a)
{
 try
 {
   m_f(a);
 }
 catch(...)
 {
   // Cannot throw exceptions from signals.
   ASSERT_BUG_HERE
 }
}
private:
boost::function m_f;
};

That is, create a new class with the right signature. So you might think: well that screams for class templates! Unfortunately, Qt does not support class templates. Doh.

So basically, we write it out:


struct SignalHandler : public QObject
{
template
SignalHandler(QObject * parent,boost::function f):
 QObject(parent),
 m_handler(new SignalHandlerImpl(f))
{}

struct SignalHandlerBase
{
 virtual ~SignalHandlerBase();
}

template 
struct SignalHandlerImpl
{
 SignalHandlerImpl(boost::function f):m_f(f){}
 boost::function f;
}
public slots:
void handleSignal(void);
void handleSignal(QString const &);
...

private:
shared_ptr m_handler;
};

void
SignalHandler::handleSignal(void)
{
typename SignalHandlerImpl type;
type* handler = dynamic_cast;(m_handler.get());
ASSERT(handler);
handler->f();
}

void
SignalHandler::handleSignal(QString const & a)
{
typename SignalHandlerImpl type;
type* handler = dynamic_cast(m_handler.get());
ASSERT(handler);
handler->f(a);
}

You can use macros to generate these handlers. You will also need overloaded connect() functions:

template
QObject*
connect(QObject * sender,
     const char * signal,
     boost::function slot);

...
template<>
QObject*
connect(QObject * sender,
                  const char * signal,
                  boost::function slot);

template<>
QObject*
connect(QObject * sender,
                            const char * signal,
                            boost::function slot);

Again, you can use macros.

I prefer Ken's solution from a technical standpoint. It is a good evolution. The main advantage of his solution is that the amount of code you need to add scales linearly with the number of arguments you need to handle whereas with my solution, they scale with the number of signals and that there are no macros.

The main advantage of my solution is that it is simpler to understand and maintain, which might be worth the extra code.

Hope that helps!

The best market is one with lots of money

noreply@blogger.com (Sohail Somani) — Wed, 19 Aug 2009 05:04:00 +0000

There are always people who feel that developing plug-ins is not a profitable market. Now while developing a plug-in may not make you as rich as Bill Gates, if there is a sizable market, you will make money.

So if you are looking for whether your idea makes sense, here is a simple relation to figure it out:

UnitPrice * NumberOfQualifiedCustomers * ConversionRate >= SomeSpecificFinancialGoal

If the statement is true, you will make money. If it is not, you will fail.

I'm pretty sure that I grossly over estimated NumberOfQualifiedCustomers when creating Worklog Assistant. How did I over calculate? Simply, the number of total JIRA users who also use JIRA as a timesheet system is quite small (yeah, duh right?) I would not have known this if I did not reach market quickly.

However, I used very pessimistic values for ConversionRate so maybe that balanced it out because I still reached my financial goals.

What does this mean for me? It means V2 is going to kick some serious ass. Oh how I wish I could have people to work on this with me, wink wink :-)

Going AFK with Bazaar

noreply@blogger.com (Sohail Somani) — Thu, 09 Jul 2009 21:12:00 +0000

One thing I've really liked about distributed VC systems is that they handle merging really well. Of course, this is not limited to DVCSs. Subversion and Perforce have very good merging but do not support offline work very well.

I've been using Bazaar for a little while now for my app because I knew that I would need to be offline every now and then. I just had one of those periods and thought it would be a great chance to see how well AFK mode works with Bazaar.

This is more for my own future reference rather than for you :-)

laptop $ rsync -avz -e ssh sohail@desktop:/home/sohail/bzr/ ~/bzr
laptop $ bzr branch ~/bzr/code/master project
laptop $ bzr bind ~/bzr/code/master

Now I can work offline in the "project" directory and all checkins go to ~/bzr .

Upon return:

laptop $ rsync -avz -e ssh ~/bzr/ sohail@desktop:/home/sohail/bzr

NOTE TRAILING SLASH ON SOURCE DIRECTORY!!!!!1111oneone....

Note: I think the above is insane. Ideally, I'd just do something like:

laptop $ bzr checkout bzr+ssh://sohail@desktop/home/sohail/bzr bzr
laptop $ cd bzr
laptop $ bzr work-offline

Return from afk:

laptop $ bzr I'm back

Or something like that.

VanCPP June meeting

noreply@blogger.com (Sohail Somani) — Mon, 08 Jun 2009 23:37:00 +0000

If you are in Vancouver and interested in programming (who isn't?!) you might want to make your way to the VanCPP meeting in June. The announcement is below:

Our June 2009 meeting will be held on Thursday, June 18. Please note the new venue.

Topic: Concurrent Programming in the D Programming Language

Presented by Walter Bright

Abstract: Many-core concurrent programming offers exciting and compelling advantages. The single core, single thread programming model is assumed by imperative programming languages. This model offers sequential consistency as its fundamental characteristic.Because many-core systems use layered cache memory systems,sequential consistency is not guaranteed among threads.Because imperative programming languages allow implicit sharing of data between threads, many misguided idioms and optimizations are possible that erroneously assume sequential consistency.One example of this is the double checked locking optimization.The pernicious nature of these sorts of bugs is they defy programmers' natural intuition about how programs behave,they are not statically detectable, and there is no way to reliably test a program to rule out the existence of such bugs.A program may appear to work, but have problems appear years later, fail when ported to a different platform, and such problems may be extremely hard to reproduce and track down.In essence, the correctness of the program relies entirely on the expertise and care of the programmer.This is not an acceptable situation for developers of programs that require high reliability.

The D programming language is an imperative programming language with an innovative type system that prevents implicit sharing and also fosters a complete, integrated pure functional subset. It is possible to statically verify that D programs do not have sequential consistency bugs. The double checked locking optimization bug is not possible. Type support for shared data and immutable data, as well as pure functions, means that mutating data interactions between threads can occur only under carefully controlled conditions.This dramatically reduces the problem space for concurrency bugs from the whole of the source code to a small subset of it, making it a much more tractable problem.

Speaker bio: Walter Bright graduated from Caltech in 1979 with a degree in mechanical engineering. He worked for Boeing for three years on the development of the 757 stabilizer trim system. He then switched to writing software, in particular compilers, and has been writing them ever since.

The meeting will be held at:
Workspace
21 Water Street
Vancouver, BC
V6B 1A

Regards,

Vladan Vidakovic

Using C++0x lambda to replace Boost Bind in C++03 code

noreply@blogger.com (Sohail Somani) — Fri, 08 May 2009 01:26:00 +0000

[Note: This post looks ugly under Internet Explorer. If you want to tell me how to fix my CSS, that would be much appreciated]
[Note: This post was written using the Intel C++ compiler with -std=c++0x.]

As some of you know, I work on Worklog Assistant which is written using C++/Qt.

One thing that I've made very good use of is a slightly modified version of the code in an earlier post titled "Using Boost Bind and Boost Function with Qt".

As an example, consider the following code from the above app which creates a popup menu to toggle the visibility of table columns. This is done by creating a "toggle" action for each column header that... toggles the visibility. It might help to think how this action would be created in plain Qt (hint: it would be painful.) It would certainly not have the locality it does now.

void
showColumnHeaderContextMenu(ssci::CustomTableView * self,const QPoint & pos)
{
QMenu columns(ssci::CustomTableView::tr("Visible Columns"));
columns.setIcon(QIcon(QString::fromLatin1(":/ui/icons/grid.png")));

QHeaderView * headers(self->horizontalHeader());

std::vector<std::pair<QString,int> > sorted_columns;
getSortedColumns(self->model(),headers,sorted_columns);

for(int ii = 0; ii < headers->count(); ++ii)
{
QAction * action =
new QAction(sorted_columns[ii].first,
            &columns);

bool is_hidden = headers->isSectionHidden(sorted_columns[ii].second);

action->setCheckable(true);
action->setChecked(!is_hidden);

using boost::bind;
using boost::function;

function<void()> toggle =
bind(&QHeaderView::setSectionHidden,headers,
     sorted_columns[ii].second,!is_hidden);

ssci::connect(action,SIGNAL(triggered()),
            toggle);

columns.addAction(action);
}

QMenu menu;
menu.addMenu(&columns);

menu.exec(self->mapToGlobal(pos));
}

Of particular interest is the code in the for loop which sets up the actions:

    function<void()> toggle =
bind(&QHeaderView::setSectionHidden,headers,
     sorted_columns[ii].second,!is_hidden);

ssci::connect(action,SIGNAL(triggered()),
              toggle);

This creates a function object on the fly which hides the selected column using code from the above linked post. To do this in plain Qt is a gigantic pain. LibQxt has a solution as well but mine is much better!

Anyway, the point is that you might find a lot of code using bind and function in an app like this. Binding member function pointers, member data pointers and function pointers is fairly normal and is really the only way to maintain sanity and reduce boiler plate. Nested binds are also used where appropriate.

Boost Bind is a way to create closures, or at least as close as you can get in C++ to true closures. Therefore it is natural to try and replace some uses of Boost Bind with C++0x lambda. There is good coverage of how C++0x lambda works here so I won't repeat the same information. However, I will cover the cases of bind I could convert and (horrifically) the cases I couldn't!

Using automatic variables

Consider the following code:

const int LICENSING_TAB_INDEX = 1;

ssci::connect(lblImportNewLicense,SIGNAL(linkActivated(QString const &)),
            boost::function<void()>(
              boost::bind(&QTabWidget::setCurrentIndex,
                          tabWidget,
                          LICENSING_TAB_INDEX)
              )
);

The above function call sets things up so that when a link is clicked in the interface, the LICENSING_TAB_INDEX tab is selected in the configuration.

One thing Boost Bind does is that it stores all bound arguments by value. That means &QTabWidget::setCurrentIndex, tabWidget and LICENSING_TAB_INDEX are all stored by value. C++0x lambda calls this capturing. This can be done using implicit capture (by parsing the lambda body) or by you. By default, C++0x lambda captures variables by reference. It is potentially buggy to capture function-local variables by reference automatically. Therefore, the above code translated to C++0x lambda is:

[=]()
{ tabWidget->setCurrentIndex(LICENSING_TAB_INDEX); }

The first element of a lambda-introducer (the []) can be a capture default which can be one of = or &. The capture default tells the compiler how to capture those variables that are implicitly captured. The assignment is supposed to make you think of copy assignment and the & is supposed to make you think of reference to. So in the above case, to get the exact same behaviour as the bind, we need to intentionally copy all variables by value.

Great! Not so bad :-)

A simpler example... Or is it?

Consider the following code:

ssci::connect(clearSelectedRole,SIGNAL(clicked()),
            boost::function<void()>(
              boost::bind(
                &QComboBox::setCurrentIndex,
                projectRoles,
                -1)
              )
);

This code sets things up so that when the clearSelectedRole button is clicked, the corresponding QComboBox has an invalid index.

The C++0x version of this is really straightforward:

ssci::connect(clearSelectedRole,SIGNAL(clicked()),
            boost::function<void()>(
              [&](){projectRoles->setCurrentIndex(-1);}
              )
);

In this case, the pointer object (not the value) projectRoles is captured by reference. This is not an issue because the pointer object is guaranteed to outlive the closure. Now you know why closures and garbage collection go together :-)

Verbosity or Why I wish C++0x used polymorphic lambdas

Consider the following code:

static
void
updateThreadSetup(QObject * parent,ssci::MainWindow * self);

m_checkForUpdatesThread(boost::bind(updateThreadSetup,_1,&parent))

The bound function in this case is an object that calls the function updateThreadSetup with a to-be-determined value for the first parameter and a fixed value for the second parameter.

The C++0x version of this is horrible:

m_checkForUpdatesThread([&parent](QObject * obj){updateThreadSetup(obj,&parent);});

First, since parent is a local variable (was passed into the function), you can't implicitly capture it. So you have to explicitly capture it. In this case, we want to capture it by reference, hence [&parent] in the lambda-introducer. Then, since this thread setup function is passed in a QObject* we have to tell the compiler to accept this argument. Apparently it isn't smart enough. Ask someone why it is this way, you'll hear some hand waving about the callable concept. Whatever.

That is some ugly code.

Anyway...

What you cannot convert without making your code super ugly

Consider the following simple code:

vector<int> d = {1,2,3,4,5};
vector<function<int()>> funcs;

for(vector<int>::iterator it = d.begin(), end = d.end();
  it != end;
  ++it)
{
funcs.push_back(boost::bind(add5,*it));
}

This creates a vector of function objects that presumably add 5 to their bound argument and return the result.

Here is the equivalent in C++0x lambda:

vector<int> d = {1,2,3,4,5};
vector<function<int()>> funcs;

for(vector<int>::iterator it = d.begin(), end = d.end();
  it != end;
  ++it)
{
int &i = *it; // WTF?
  funcs.push_back([i](){add5(i);});//THIS IS REDUNDANT. REDUNDANT.
}

Naively, one might have done:

funcs.push_back([it](){add5(*it);});

in the loop. But this is a bug waiting to happen. Add the following line right after the for loop:

d.push_back(0)

Now all those iterators that are captured by value can be invalidated! YAY! The only way to avoid this issue is to manually extract the value referenced by the iterator and pass that into the closure which is what I did in my translation.

Conclusion

This exercise showed me that C++0x lambda is of some interest to me. I'd really like to get rid of the verbosity (I know, too late!) A couple of things would make this the perfect lambda for me:

Polymorphic lambdas (or at least let me specify auto for the arguments)

An easy way to capture computed values (the *it bug above)

I don't know how these problems would be solved, or whether they could be but until they are, I think there is still a future for function binding ala Boost Bind which is fine by me!

BoostCon 2009

noreply@blogger.com (Sohail Somani) — Mon, 04 May 2009 04:23:00 +0000

BoostCon starts tomorrow.

I went to the first and second Boost conferences. The first as an attendee, the second as a speaker. I was blown away by the quality of the talks, particularly the author's corner series of talks. I think that if the organizers are smart about it, this can be one of the best conferences. For me, it is already on par with conferences like SD West for quality and relevance.

I am extremely disappointed that I could not make it this year due to my schedule being way too busy. I hope that some of you reading this have been able to schedule better than me and go to BoostCon.

If you are attending, please ask at least one very difficult on-topic question in each of your talks for me.

Also, ask Joel de Guzman about Boost.GUI. Apparently he's got something cooking (you didn't hear it from me!)

A seemingly complete Qt API for CL

noreply@blogger.com (Sohail Somani) — Thu, 19 Mar 2009 22:51:00 +0000

Just came across this library called CommonQT.

It is more complete than the API I developed earlier. It is also using the KDE Smoke libraries which make it damn easy to create the API on the fly.

Very exciting.

Latest NVIDIA drivers, Ubuntu Edgy

noreply@blogger.com (Sohail Somani) — Sun, 15 Feb 2009 22:01:00 +0000

NVIDIA drivers not loading after the latest Ubuntu update? Low resolution mode?

They used to work didn't they?

Before you start uninstalling Ubuntu packages and installing the official NVIDIA drivers, throwing your hands up and generally having a bad day, try this:

(as root): echo nvidia >> /etc/modules

Reboot. Should work now.

For some reason, you need to explicitly load the module with the latest nvidia packages (I'm using nvidia-glx-new)

Qt goes LGPL!

noreply@blogger.com (Sohail Somani) — Wed, 14 Jan 2009 08:51:00 +0000

http://www.qtsoftware.com/about/news/lgpl-license-option-added-to-qt

Now that's awesome.

Using Boost Bind and Boost Function with Qt

noreply@blogger.com (Sohail Somani) — Wed, 26 Nov 2008 19:03:00 +0000

One very, very, very annoying feature of Qt in C++ is how very difficult it is to create bespoke slots.

With gtkmm, you can more or less get away with using boost::bind so long as the bind results in a 0-ary function (otherwise the signal/slots library for gtkmm is not compatible.)

With Qt, you have to write a new member function, or heaven forbid, a new class. This is too much typing for me. Ideally, what I would like to do is something like:


connect(some_button,SIGNAL(clicked()),
        boost::bind(&Foo::bar,something,else,entirely));

Doing this with bare Qt, I'd have to:

Create a new slot function: Foo::bar_special_case

Add member variables for the variables else,entirely

Finally use it as: connect(some_button,SIGNAL(clicked(),something,SLOT(bar_special_case()))

After doing this for the 100 billionth time, I realized that there should be a better way to do this. After months of investigation, I have discovered that there is no better way to do this.

Just kidding.

The idea is to create a slot handler that accepts boost::function types:


struct SignalHandler0 : QObject
{
private:
  Q_OBJECT
public:
  SignalHandler0(QObject * parent,
                 boost::function<void(void)> const & f):
    QObject(parent), // parent will delete this object when destructed
    m_f(f) {}

public slots:
  void
  handleSignal()
  {
    try
    { 
      m_f();
    }
    catch(...)
    {
      // Cannot throw exceptions from signals.
      ASSERT_BUG_HERE
    }
  }
private:
  boost::function<void(void)> m_f;
};

If I were to use this class directly, I would write:


connect(button,SIGNAL(clicked()),
        // Note: Not a leak as button will delete the handler when destructed
        new SignalHandler0(button,boost::bind(&Foo::bar,something,else,entirely)),
        SLOT(handleSignal()));

That's pretty much it. Of course, this is a bit too verbose so I'd write a free function:


bool
connect(QObject * sender, const char * signal,
        boost::function const & f)
{
  return QObject::connect(sender,signal,
                          // Note: Not a leak as sender will delete the handler when destructed
                          new SignalHandler0(sender,f),SLOT(handleSignal()));
}

And use it as:::connect(button,SLOT(clicked()),boost::bind(&Foo::bar,something,else,entirely))

The obvious problem with this approach is if you add any overload of the free function + bind and you are in for some fun. I prototyped a solution for this based on the Boost.FunctionTypes library but at the moment, I don't need this (i.e., I am happy with 0-ary bind)

Another thing... Why does the aforementioned function types library not handle boost function and boost bind?

Odd.

PS: I'm not dead. I just smell funny.
PPS: Sorry for so long in between posts, I've been very busy (the good kind!)

Everything you ever wanted to know about tr1::function but were too afraid to actually know

noreply@blogger.com (Sohail Somani) — Sun, 05 Oct 2008 19:17:00 +0000

Working title for a talk I'm giving October 16 at the Vancouver C++ Users Group.

I find three patterns of usage around Boost Function/Bind:

The right way

The wrong way

Running away

My goal for this talk: attendees should no longer be in the dark about how Boost Function/Bind (and by extension, tr1 function/bind) work. If you are reading this blog, coming to this talk, not the author of this post and you have some things you'd like to hear covered, please feel free to leave some comments. I'm pretty sure the intersection of all those groups of people is the empty set but it never hurts to ask!

Heckling must be reserved for the end.

PS: Regular posting will resume some point soon!

Qt/Lisp: more progress

noreply@blogger.com (Sohail Somani) — Thu, 31 Jul 2008 15:06:00 +0000

I've replaced the unsightly (make-instance 'qstring :ch "Foo") with a reader macro: #q"Foo". Ideally we'd use cl:string and qstring interchangeably but right now its too much of a PITA to make that work.

I've also made it possible to use closures for slots (see example below.) Frickin sweet.

Anyway, I started getting into the Dock Widgets example but lost interest after seeing all the code. Here is the code so far. Not very concise yet but will get there. Once I get into make-it-less-ugly mode, I will probably copy what Paul did with EQL as he calls it now.

~~Also the :foreign-pointer thingy will go away when I get around to adding cffi type translations.~~

svn-bisect

noreply@blogger.com (Sohail Somani) — Mon, 28 Jul 2008 23:04:00 +0000

Well it was only a matter of time... svn-bisect.py lives!

Greg Noel of SCons fame (is that really fame?) has committed a modification of a script I created whose purpose was to binary search the introduction of a bug in a SVN repository.

Example usage of the script is here.

Enjoy.

Why complaining works..

noreply@blogger.com (Sohail Somani) — Mon, 28 Jul 2008 22:51:00 +0000

My email to an online store:

Hey guys, I ordered product XYZ from your site yesterday. According to your shipping estimates, it should be here in 2-4 days. However, I see that it is not shipped yet. I have had one bad experience with your service before and would not like it to repeat. Please see that this is so.

Literally 5 minutes later:

Your order has been shipped.

Now if I can only get them to do it before I complain.

Simple CFFI - Qt4 integration attempt

noreply@blogger.com (Sohail Somani) — Tue, 22 Jul 2008 17:04:00 +0000

Update: Paul has sent me his code. He calls it "EQL" for ECL and Qt. Or something like that anyway! I have put it up here.

The author of the Simple CFFI - Qt4 integration attempt has contacted me to let me know that a modification of the above linked software is in commercial use. I have prodded him to release his modified version. He says he'll do it Real Soon Now (TM).

I don't know if he is reading this blog but maybe a little pressure will help. Just kidding!

What I like most about his method is the use of the introspection capabilities of Qt. Compared to the duct tape and glue I used, his is a lot more elegant. Currently, you cannot extend Qt in Lisp (via inheritance) but all the other goodies are still there. Indeed he tells me that for his application, he extended Qt from within C++ and used these extensions from his Lisp.

I look forward to the update and to using the library.

Qt/Lisp: looking for feedback

noreply@blogger.com (Sohail Somani) — Fri, 18 Jul 2008 17:22:00 +0000

Update: You can download the generated code from here.

The tubes were down this morning, so I managed to get up to tutorial 6 in my Qt/Lisp API. It covers about 95% of the API by design so most of the non-extension tutorials/examples should work.

Tutorial 1:

Tutorial 2

Tutorial 3

Tutorial 4

Tutorial 5

Tutorial 6

I would like to hear your complaints, suggestions, feedback if you have any.

Note that this API is a first draft and I thought it better to have something out there than wait until everything is perfect.

To start with, my current complaints:

(in-package :qt) -> Nothing is actually exported from the package yet :-)

~~(make-instance 'qstring ...) -> A really verbose way to pass a string! Should convert lisp strings to qstrings automagically.~~

Naming: instead of qpush-button, q:push-button

No way to extend Qt from within Lisp yet (tutorial 7 won't work)

~~No way to attach arbitrary functions as slots~~

Not Lispy enough.

I expect to address most of these at some point though the "Not Lispy enough" complaint is a bit subjective.

Sohail, it doesn't work anymore

noreply@blogger.com (Sohail Somani) — Wed, 09 Jul 2008 16:56:00 +0000

Everyone has a story about when they were younger. For example, Joel Spolsky talks about his time in an army bakery (or something like that.) Sometimes, the stories are quite pathetic like Al Bundy and his high school football team. I am neither as exciting as Spolsky, nor as pathetic as Al Bundy (though I'm sure the latter is up for debate.)

This story is about something that happened to me when I was younger that made me who I am today.

I started programming quite late by geek standards. I was either 11 or 14 depending on whether you count batch files as programming. But I loved it. And when I got tired of programming, I'd program some more in FastTracker 2!

For a while, I had a job as a pharmacist's assistant. This particular pharmacy had the option for delivery of prescriptions and other general items. The deliveries were done in the evening and were done by two very friendly guys named Krish and Sam.

Part of my job here (besides preparing the methadone!) was to add up all the deliveries that these two guys did within some period of time and summarize for the boss. It used to take me hours in a busy month as it required use of some large Excel spreadsheet. So I resolved to solve that problem with my programming chops. I got the owner to agree to pay me hourly (wow, $10/hour!) and he told me not to spend "too much time" on it. So I guesstimated 40 hours until I would be able to deploy the application. He was fine with that.

I was mostly right but near the end of it, while I was testing with the users (me), it turned out some other data collection was necessary. After discussing with the boss, he said it was important but not to spend "too much time" on it. By then, I had come to realize that "too much time" means "don't charge me more than I want to pay you." So I added it quickly, and it was done.

I deployed the application in December of that year to rave reviews from the boss. I'm not sure if the other employees cared that much but I know that it made my life easier and the count of deliveries more accurate so I was happy.

Due to other responsibilities (I think it was school?), I had to reduce my hours at the pharmacy. That was around June. I had trained the other people to use the application and it was becoming quite necessary for them to use if they wanted to retain their sanity.

Fast-forward to November. I get a call. "Sohail, it's not working anymore." "Crap", I thought. What did I miss? I went into the pharmacy and fudged around in the flat files to see what could be wrong.

It turns out that one of the data files was being named incorrectly. Can you guess which data file? Yes, it was the one I had added last just before I completed the project.

I think I spent about 10 unpaid hours debugging the problem at home while studying for exams/finishing projects. It came down to this (in C++, I don't really recall the language):


// data1.cpp
const char * months[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};


// data2.cpp
const char * months[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov ","Dec"};

Can you see the problem? In the second instance, I added a space after "Nov". So while data2.cpp was saving "Data2Nov Year.file", data1.cpp was saving "Data1NovYear.file" and the code that summarized the data was trying to open "Data<N>NovYear.file".

Oops.

I fixed this bug and apologized to the owner. I explained why it happened and that I fixed the code duplication. The boss said that he thought I should get an award for this software (a big ego boost!) and wondered if he could sell it to other people. Apparently he had been raving about it to his other pharmacist buddies. I don't remember what I said to him about that (something about me not having enough time to modify it to be generic enough as Sam and Krish were hardcoded!) but I really learned something that month.

Fortunately, in this case, things turned out alright. So I swore to avoid similar problems in the future in case future clients were not as forgiving. How did I do this? Quite simply:

Thorough testing

No copy-and-waste

My business cards have always had some variation of this. The current incarnation has something like "Do it once, do it right." Corny, but conveys my philosophy quite well. I will work very hard to reduce code duplication now. I try my best to write a test for each function/class that I write. Yes it is hard work. Yes it takes time. Quite frankly, software is hard. But in the end, I get very few calls saying "Sohail, it doesn't work anymore."

And no, you are not allowed to put a comment on this post saying "Sohail, it doesn't work anymore" :-)

Automatically rescale a Gtk::Image (and preserve aspect ratio)

noreply@blogger.com (Sohail Somani) — Tue, 24 Jun 2008 04:32:00 +0000

Don't really have enough time to explain it all, but hopefully the comments help. Here are a couple of screenshots:

The image used in the examples above is here.

And the code:


/*
  Problem:

  Using GTK, display an image in a window and rescale when the window
  resizes preserving the aspect ratio.
  
  Analysis:

  Gtk provides Gtk::Image which works on a Gdk::Pixbuf (pixel buffer)
  which allows rescaling but without preserving aspect ratio.

  Summary of solution:

  Use a Gtk::Image embedded in a Gtk::AspectFrame and resize image
  using dimensions determined by Gtk::AspectFrame. The AspectFrame
  knows how to maintain a ratio so it does the messy work for us.

 */

#include <gtkmm.h>
#include <iostream>

/// This Widget only scales the image but does not preserve
/// aspect ratios.
struct ScalingImage : public Gtk::Image
{
  explicit
  ScalingImage(Glib::RefPtr<Gdk::Pixbuf> pixbuf,
               Gdk::InterpType interp = Gdk::INTERP_BILINEAR):
    Gtk::Image(pixbuf),
    m_original(pixbuf),
    m_interp(interp),
    m_sized(false)
  {
  }

protected:
  virtual
  void
  on_size_allocate(Gtk::Allocation & r)
  {
    // This event is fired on all Widgets when their rectangle gets
    // resized. So we rescale our image. But rescaling our image fires
    // another resize event, and another, and another... You see the
    // problem!
    //
    // The most straightforward solution is to not rescale the image
    // the second time the event is fired. Hence the m_size toggle.
    //
    // Ideally I'd not like to do this but this was the best way I
    // found!
    if(!m_sized)
    {
      Glib::RefPtr<Gdk::Pixbuf> scaled = 
        m_original->scale_simple(r.get_width(),
                                 r.get_height(),
                                 m_interp);
      // Reset the image to be the new scaled image which
      // will cause the second size-allocate signal
      Gtk::Image::set(scaled);

      // Make sure we don't treat it as a rescale request 
      // next time
      m_sized = true;
    }
    else
    {
      // Reaction to set above. Call the base class's on_size_allocate
      // function. Shouldn't I have to call this above too? Maybe it
      // isn't necessary since it gets called anyway.
      Gtk::Image::on_size_allocate(r);

      // Treat next resize event as a rescale
      m_sized = false;
    }
  }
  
private:
  Glib::RefPtr<Gdk::Pixbuf> m_original;
  Gdk::InterpType m_interp;
  bool m_sized;
};

/// This widget automatically scales the image but preserves the
/// aspect ratio of the original image. This is accomplished via use
/// of the AspectFrame class
///
/// Ideally would like this to be a Gtk::Image subclass.
struct AspectPreservingScalingImage : public Gtk::AspectFrame
{
  explicit
  AspectPreservingScalingImage(Glib::RefPtr<Gdk::Pixbuf> const & pixbuf,
                               Gdk::InterpType interp = Gdk::INTERP_BILINEAR):
    m_img(pixbuf,interp)
  {
    set(Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER,
        // Aspect ratio of frame
        pixbuf->get_width()/float(pixbuf->get_height()));
    // This makes it appear as if there is no frame
    set_shadow_type(Gtk::SHADOW_NONE);
    // This allows a minimum size
    set_size_request(pixbuf->get_width()/2,pixbuf->get_height()/2);
    // Finally, add the image to be managed
    add(m_img);
  }
private:
  ScalingImage m_img;  
};

int main(int argc, char* argv[])
{
  if(argc != 2)
  {
    std::cout << "Usage: " << argv[0] << " <image-file>" << std::endl;
    return 1;
  }

  Gtk::Main kit(argc,argv);

  Gtk::Window win;
  Gtk::VBox box;
  win.add(box);

  Gtk::LinkButton lb("http://www.utahskies.org/image_library/deepsky/constellations/orionwa.jpg");
  AspectPreservingScalingImage apsi(Gdk::Pixbuf::create_from_file(argv[1]));

  box.pack_start(lb,Gtk::PACK_SHRINK);
  box.pack_start(apsi);
  
  struct launch_browser
  {
    static
    void
    doit(Glib::ustring const & addr)
    {
      std::string command("firefox ");
      command += addr.c_str();
      std::system(command.c_str());
    }
  };

  lb.signal_clicked().connect
    ( 
     sigc::bind(
                sigc::ptr_fun(launch_browser::doit),
                lb.get_uri()
                )
      );
      

  win.show_all();

  Gtk::Main::run(win);
}