Smart Software

Everyone's a "Vice-President"

MSNBC has a news video called "Title Wave - Everyone's a Vice President." The video points to a 22-year-old Japanese female and recent college graduate, who is a vice-president of HR operations at a US software company (TopCoder). Donald Trump actually says in the video that he gives away vice-president titles in lieu of salary increases to retain top talent.

When I first looked into the "facebook" of classmates of my MBA program, I was stunned to find that perhaps half or more of my classmates have VP titles or equivalent or better. I soon learned about the phenomena of title inflation, especially in the finance industry, where investment bankers two years out of college are commonly handed a VP title. The video above states that Goldman Sachs has 6,500 vice-presidents; in fairness, these junior VPs often have salaries exceeding those of genuine vice-presidents in other industries.

I always thought that the vice-president title may have some legal significance, such as indicating authority of a company officer. I know that it's important to use one's correct legal title in company documents, because the misuse of certain titles (eg, partner, CEO, member, manager, owner, proprietor) may confuse other parties and introduce personal liability in a court case where there would otherwise have been none. Many financial companies are/were limited partnerships, so actually a vice-president title is perhaps legally empty in comparison to a "partner" title.

It is easy to get a VP title by joining a startup; it's even easier to get a CEO title by filing an application for a new company. Some companies even mock the vanity of these titles by coming up with new hilarious ones like "Chief Yahoo." (Pardon me. I can't really recall any better titles, because of their infrequency and uniqueness.)

SBIR (Small Business Innovation Research) Grants

During my MBA program, I investigated government programs for granting money to small business programs to conduct and productize technology research. There are two programs (SBIR and STTR) in which eleven different government agencies provide two billion dollars in grants to small technology companies.

I actually wrote a preliminary proposal, which was modeled on a copy of a successful proposal provided to me from one of my classmates, Holly. The proposal was sent for developing feedback-controlled sports bra for SmartWear, Inc. While she was not the "principal investigator," she wrote the proposal, which led to a National Institute of Health grant in 2001 of $100,000 for six months to a year of work.

I never sent in my proposal, since, at the time, I missed the proposal deadline which was infrequent (once a year) and estimated my chances of success at being low, since it involved natural language. The large companies (IBM, Google, Microsoft) have hundreds of researchers, developers, and linguists, compile massive amounts of data and pour millions of dollars into research. With me, my credentials and my product ideas are in doubt; I am not going to convince anyone reading my proposal that I have a better way especially with a $100K grant.

The couple, who developed the Dragon Software speech-recognition technology, subsisted for seven years during the 1980s through government grants, before they were able to release version 1.0 of their software.

I have been thinking that my static analysis tool could actually fare better. I have working technology right now as well as demonstrated commitment using my own time and funds. My background (schooling and prior work experience) is very good. There is still quite a bit of work that I need to do to take it to the next level.

The government agencies examine proposals more frequently, four times a month, with DoD solicitations arriving in Nov 1 and the next proposal deadline in January. However, proposal writing and benchmarks are a time sink, and I could probably just do better organically by keeping focus on my development and funding my research through internal cash flows. I do wish that I had submitted a proposal last year.

Mom

In an article "How Far Behind Is Linux" in the Wall Street Journal, Lee Gomes interviews Linus Torvald and learns that his own family members in his native Finland don't use Linux.

Among Microsoft's customers, concedes Mr. Torvalds, are his father and sister, though Mom has managed to resist the allure of the dark side.

The mom bit was interesting to me. We have all heard the saying that software should be made easy enough even for Mom to use, but it was only a few years ago when I really begun to appreciate the mom phenomena.

Back around 2003, when I visited my parents back in New York, I resolved to teach Mom how to use the computer or more specifically the Internet.

I showed my mom how to use AOL to access the Internet. I found websites that I thought she would be interested in, like switchboard.com(?) for searching phone numbers for all of her friends around the country. The people search feature piqued her interest, but I never succeeded in getting her to befriend the computer. Instead, when Mom is interested in knowing the whereabouts and contact number of someone, she calls me so that I can look it up on the Internet.

Later, I discovered how much of an extreme technophobe my mom was. She never even used an ATM machine. She always meets with the bank teller to deposit and withdraw money. Everyone else in the household uses a computer, and I always assumed that she encountered computers when she used to work.

I wonder if there is still an hope for her. Perhaps, something like WebTV (now it's called MSN TV) would help. AOL still has too many steps for beginners.

Distractions

I haven't been very productive in the past few weeks as I have been preparing to move and clear up longstanding issues. I was hoping to move after my product's release, but background stress stemming from my current living situation and increases in my living costs spurred me to leave earlier. (I was also hoping to save a move, because I'll likely move again to a more permanent location within months after release.)

I am simply not as productive when I have multiple concerns in my head. Perhaps, my tendency to program at night is not historically conditioned behavior but rather my body's real preference to work in environment of minimal distractions--of complete silence, when no other activity is possible.

The worst thing about moving is that, as a finicky developer, I need to acclimate myself to my new home--air quality, temperature, lighting, etc, just right--especially, since I work at home. An office building will typically have healthy and comfortable indoor environment that's already been heavily pre-tuned for working. I suspect that's why many people find that they are unable work at home. The oxygen level at work seems higher, even though I have made sure that air circulates frequently from the outside.

I also seem to be short on energy. Right now, I sustain myself with RockStar energy drinks, PowerBars energy bars, lots of water, and occasionally coffee. I almost moved away from energy bars because of concerns about corn syrup and its potential link to obesity and diabetes, but many of the energy bars have replaced corn syrup with healthier substitutes since the beginning of the year. Ephedra, an effective supplement which I used to buy, is now legal again, but in some stores can only be purchased in the pharmacy.

My first priority after release is to kick start my health routine. It's easier to reform habits after a major transition in life. I just bought a glucometer and a pedometer. My blood sugar level is elevated, and I suspect that in another decade or so, I could be at a high risk for diabetes, given my family history. I am also keeping watch on my other vitals.

In recognition of my decreased output, I postponed several features for future minor updates to focus on the core and delivering before the end of year; there's still surprising stuff (such as manipulating arbitrary functions) that I haven't demonstrated yet.

My main concern, right now, is that my product doesn't "hang" during a scan. Here, "hanging" really means "not performing quickly," since I do not have the capacity to test long-running scans. A "hang" is also a sure sign of a blow up, which I have tried not just to mitigate, but eliminate in many circumstances. The consequences of not exploring the full search space in my product is not severe, since I still have a partially simplified expression that can still serve as a value with equivalent properties.

WPF Redux

I spoke to someone in the WPF team regarding a post I wrote about my eventual plans to incorporate WPF into a future release of my product. The post was http://wesnerm.blogs.com/net_undocumented/2007/07/orcas-beta-2.html. My prior concerns were alleviated in the discussion.

The Complete Package

There were some bloggers who mentioned the WPF wasn't ready for prime-time and this was because of the lack of controls, but that's not really a problem if WinForms interoperability or third-party controls are used. I am currently looking at four different control providers--Infragistics, Actipro Software, DevExpress, and DevComponents DotNetBar. At least one of them (DevComponents) recently came out with a full set of user interface controls.

Download Bits

Another point was raised about my comment regarding 2.8 megabytes being added to my setup package. I was referring to the WPF redistributable dotnetfx3setup.exe for Windows XP: http://www.microsoft.com/downloads/details.aspx?FamilyID=10CC340B-F857-4A14-83F5-25634C3BF043&displaylang=en. Actually, that's just the initial download size; .NET 3.0 install actually adds ~26mb on top of the ~25mb .NET 2.0 install. For my purposes, anyone using latest versions of Visual Studio will already have these installed anyway, and download size and bandwidth costs aren't really issues anymore.

WPF Isn't Always Pretty.

In the second major version of my product, I will likely go full-steam with WPF. WPF doesn't seem to be a major hurdle as it once was.  My major motivation is that there are user interface enhancements that I want to realize that aren't currently possible in the WinForms platform.

WPF won't automatically make an application more beautiful; as used to be the case with many Microsoft applications at least three or more years ago, the default settings tend to the ugly. Eric Sink expounds on this with his post "What Microsoft Doesn't Want You to Know about WPF" regarding his experience creating the Sawdust app using WPF:

In fact, many developers are under the impression that WPF apps are just naturally pretty.  They believe that something about the platform makes the user interface look great, automatically, with no extra effort.

This is not true.

What Microsoft doesn't want you to know is that it is possible to make ugly applications using WPF.  In fact, ugly is not merely possible -- it's the default.

Nevertheless, the potential for great-looking applications is there.

I'm not blaming WPF for the fact that my application is ugly.  I'm just trying to dispel the myth that WPF applications are naturally easy on the eyes.  Just as with any other UI platform, making a nice-looking app with WPF requires design skills, and I don't have any.  Eventually I'll get some help and make it not so hard to look at.

I was a bit surprised at the "open-sourcing" of WPF. I never regarded the source of WinForms as being very valuable, which is very much a wrapper over Win32, where the real meat is hidden, but WPF contains some core IP like the text engine. My first thought was what happens when engineers from a country like China that doesn't respect IP reviews documented source code. I guess these same issues exist for real open source.

Immutable Data Structures in C#

In the post on Path Finding using A*, Eric Lippert, programmer in the Visual C# team, writes that immutable data structures are the way of the future in C#. As immutable data structures have been a frequent posting topic of mine, I am really happy about this direction towards immutable data and functional programming that C# is taking. My only quibble is that the last two words, "in C#," are not really necessary.

The frequent complaint of functional programming is that it is slower than procedural programming. However, I discovered something else: As you know, the immutable data structures for maps may be slower for some operations than their imperative cousins, but the running times for all the operations are typically acceptable and well-balanced. (Even then, I did bring up in a recent post a version of persistent hash-tables and array used by COQ that offers nearly identical performance). Plus, these data structures are very flexible--able to be used freely anywhere with no constraints.

Most of my data structures in NStatic and elsewhere are immutable. In my data structures, the equality and the copy operation are constant-time, even for large object trees. The immutability and balanced performance allows many otherwise exponential algorithms to be done efficiently. A good example is the use of dynamic programming in which function values are "memoized" (sic); this technique is absolutely essential for natural language parsing.

Wes Dyer, another developer in the C# team, wrote early this year that "imperative programming is sometimes reminiscent of a Rube Goldberg machine. Both require meticulous thought to ensure that a process works correctly despite a myriad of state transitions and interdependencies. It is amazing these complicated programs work at all." Hmm... could he be referring to any popular application software that we know of?

That Microsoft and the rest of the world programs imperatively and suffers the consequence of their decisions is the main reason that I can even consider developing the software that may indirectly compete with their own.

Books and Software

Charles Petzold, well-known author, writes about Hard Work, No Pay: What's the Point?, a response to Jeff Atwood's post on publishing his own first book.

I looked into the economics of writing books, and, considering the amount of time it takes to actually write a book (Charles says six months to a year of full-time work), writing software seems economically more viable.

Well-known .NET author Chris Sells takes in five dollars per book he authors, but, with gross margins in the 90%, I could easily fetch thirty times that amount per software license. A unique piece of software could fetch far more copies than any individual book.

Also, software upgrades and subscriptions provide an annuity stream with low effort and risk. I doubt that new book editions pull anywhere the same repurchases. The code-base of one software package can be reused, modified and repurposed to produce a second related software package.

I do wonder sometimes about a very targeted e-book, which combines aspects of software and books. E-books typically have less content than books, but are often priced the same (without the middleman).

Type Names

I picked up a lot of interesting knowledge about C# in the course of developing and testing a parser for the language. I'll try to post a few tidbits as they come to mind again.

One nice tidbit is how to create new short type names without having to specify the full name of every non-primitive type, especially inside of generic type names.

Normally, using "using" to create a new type name, even in the presence of the appropriate namespace import, one has to fully qualify every type name that is not a keyword.

using System.Collections.Generic;
using T = System.Collections.Generic.List<string>

However, if the "using" is inside a namespace, then it will utilize any imports located in an outer namespace.

using System.Collections.Generic;

namespace MyCompany
{
    using T = List<string>;
}

Specifications

My main tasks in the past couple of months have been divided between bug-fixing and improving scalability. In the latter case, testing on large projects revealed bottlenecks caused by uncontrolled expression growth, for which I came up with a general solution. I have been spending a considerable amount of time on my simplifier for recursive lambda expressions.

There was one major addition. I added syntax support and highlighting for eventual specification support. My immediate goal was to provide a clean way of adding breakpoints and assertions to the source code.

The above visual shows what the new syntax highlighting looks like. The new keywords are bolded. Two new grayed out comment delimiters were added: //@ and /*@. These comment delimiters act like white space from within NStatic with the exception that new keywords are only recognized within the comments.

Any arbitrary code, such as ghost fields, can be placed inside these comments; this serves as an alternative to using the preprocessor defines, NSTATIC and CODEANALYSIS.

The new keywords that I have included: require, ensure, assert, assume, pure, modifies, invariant, old, breakpoint, result, unreachable, and nonnull. But, for the first release, the only keywords that are actually effective are assert, assume, breakpoint, old. Assert actually verifies that the expression is true and returns a warning otherwise (or error in the case of an invalid code path). The behavior is stronger than a call to Debug.Assert. Assume does not require the expression reduce directly to a true value, but it will produce a error if there is a false path leading to it.

The specifications are modeled on both Java Modeling Language (JML) and Spec#. There are quite a number of differences between the two. For instance, JML incorporates method contracts before the method declaration whereas Spec# incorporates contracts just right before the method block. While I followed the Spec# in this case, my instinct is to prefer JML, because it is more of an industry standard, and I am less likely to encounter Microsoft IP issues.

I suspect highly that the next version of C# will incorporate some kind of design by contract.

There are a few differences from both JML and Spec#.

• Arbitrary functions are supported as expressions with specifications, including impure functions (functions containing side-effects). Side effects that occur inside the expression of a single specification are not visible to other parts of the program, including adjacent specifications.

I have never taken a course in formal methods, so I am not fully aware of the implications of my approach.