Smart Software

3D TV

In a prior post, I wrote about 3D Displays. Well, the New York Times wrote an article about new 3D TVs emerging within five years via Emergic.

Ordinary TV sets deliver 500 lines of resolution. Most high-definition screens reach 1,050. The HD3D hits 1,280 lines and counting - which means better picture quality than that of any TV available today, all in a convincing impression of the third dimension. And here's the seriously trippy part about the new screen, which Deep Light plans to introduce at next winter's Consumer Electronics Show in Las Vegas: multiple "blades" of video enable one screen to show different programs to different viewers, at the same time.

Imagine what that could do to your living room. Your kid sprawls on the floor, happily splattering the virtual walls of Quake 3-D, while you sit on the couch watching the news and your spouse beside you talks with friends in a virtual chat room - all on the same TV, all at the same time, and all in 3-D. Lean a few feet to the right and the latest report from the floor of the stock exchange becomes a live 3-D chat with the couple who came over to dinner the other night; lean the other way and Junior is blasting a zombie. And something similar is going on over at the neighbor's. And halfway around the world.

We see the world in three dimensions, but throughout most of history, we've only been able to depict it in two. Until recently no one had come up with a better solution to this problem than goofy eyewear. When Rover sent back images from Mars, NASA scientists studied them wearing much the same glasses that audiences in 50's movie palaces donned to watch "It Came From Outer Space."

Within the realms of industry, that's been changing, as what's known as stereoscopic imaging has become a big business involving everyone from drug researchers doing molecular mapping to car designers building next year's SUV. Culturally, however, it remains a novelty, consigned to the occasional theme park ride or Imax film. Recent commercial film releases, like "The Adventures of Shark Boy and Lava Girl in 3-D," have raised its profile a bit, but they still rely on the dinky glasses.

But the ever-evolving high-tech revolution is finally moving 3-D entertainment to the next stage. Sharp has sold three million 3-D cell phones in Japan since 2003 and has just released a laptop that toggles between 2-D and 3-D views. The South Korean government, meanwhile, recently announced an ambitious "3-D Vision 2010" project to make stereoscopic TV the worldwide standard within five years, and a number of companies are racing Deep Light to build the pieces of that puzzle; just in April, Toshiba announced new display technology for 3-D television screens. "The whole realm of TV," says Chris Chinnock, the president of the market research firm Insight Media, "is the Holy Grail of 3-D."

The Lure of Free Software

I just recently purchased a myriad of software for operating my MicroISV and accelerating my time to market. I spent a considerable amount of money on these intangible, invisible goods. Where I would normally hesitate to spend a few hundred dollars on real physical goods for my business, I find a way to rationalize the cost of an information good. Even stranger, often I regret the software purchase, since I wasn’t able to put it to effective use—this is usually not the case with physical goods. Physical goods are also easier to resell, not the least because physical goods are sold not licensed.

Eventually, the impact of software purchases on the bank account becomes apparent. While at Microsoft, I was spoiled. I was able to get Microsoft software up to a tenth of the retail cost.  As an ex-employee and member of the Microsoft Alumni Network (MSA), I still do get heavily discounted Microsoft software at employee prices but with a little over half the budget of regular employees.

I spent a little over $300 for my last MSDN subscription, the price Microsoft employees and contractors can get it at. Since I am neither now, I have the option of using the ISV Empower program to obtain an MSDN subscription or getting a special discount for ex-employees recently negotiated by MSA.

The perks distorted my buying patterns, causing me to rely on the less powerful but easier Microsoft packages (eg, tax and financial software) in place of the industry standard packages. I, for example, held on Microsoft Digital Image Suite for some time before I actually purchased Adobe Photoshop.

The perks clouded my thinking and probably those of many other Microsoft employees. It’s easy to disregard open source software as “inferior” software and not a threat, if we don’t feel the financial impact of purchasing software. (I put “inferior” in quotes to indicate the perception from within Microsoft, not necessarily the reality.)

If it weren’t for the perks I still enjoy, I can imagine myself opting for freer alternatives (StarOffice, GIMP) especially if I had a number of employees. Human nature dictates that I care less about employees’ experiences with less usable software than I do my own, while the almighty dollar demands my constant worship. I would still stick with Microsoft Windows operating system, though, as I have little choice, if I want to sell a commercially viable application.

This, apparently, is the motivation for the ISV Empower program, enabling new developers to get started developing commercial software for the Windows platform without forgoing a sizable fraction of one’s salary before seeing any revenues.

 

Personal Offshoring

Slashdot had an post a few years ago about a developer who was able to get paid $67K for an assignment, in which he outsourced to India for $12K. This post caused a stir in India, who felt underpaid.

I just came back from the Shareware Industry Conference, where I met someone in the shareware business, who made millions ($3,000 to 6,000 a day) from his first product in the mid-90s selling for $10 – 15 dollars a simple program that changed two registry keys to make Internet browsers perform faster. He had only learned to use a computer a few years earlier. (Note: His sales rate grew from an original $300/day because of RealNetworks promotionin its website in exchange for a cut.)

This entrepreneur is not a developer, so he had to pay a student to develop the application. In later years, he hired developers from Russia and Israel to produce additional applications, since they were much cheaper than hiring one from the states. Having written earlier about outsourcing, I inquired about how he was able to find such developers, but he didn’t give any details.

Last week, Guardian Unlimited had an article on Swift and Offshore which describes how individuals can make cost and time savings by offshoring their own work. Examples include using RentACoder.com to hire a Belorussian developer to produce two-weeks worth of code for 200 pounds, or using templatekingdom.com to hire a Bangladesh developer to produce a website design for 30 pounds.

C# News

PDC session abstracts have recently gone live with some new details on the C# language. Some of the other tracks don’t really intrigue me as much. Avalon and Indigo are already in beta, so I don’t expect much to change before release. IE7 needs to play catch up in web standards, and ASP.NET 3.0 is interesting, but I am not very likely to play with it before its release, when hosting providers are available.

It appears that Meijer paper on the bridging of dynamic typing with static typing extrapolates from trends in the C# programming languages rather than indicates any new features in the language.

I gather from the details that C# will include support for querying databases and XML, but this support doesn’t come from domain specific extensions to the language as I initially feared. The database support is primarily from “Integrated Query Framework” (IQF) library, included in the .NET Framework, allowing all .NET languages to benefit and also to avoid aging any of the languages. IQF includes “a strongly typed data access framework and an innovative API for manipulating and querying XML.” To support the IQF, the C# language includes general-purpose extensions such as “extension methods, lambda expressions, type inference, and anonymous types [which] make it possible to create powerful APIs for expressing queries and interacting with objects, XML, and databases in a strongly typed, natural way.” Cyrus Blather also mentions implicit types and expression trees.

Information in the VB abstracts indicate similar capabilities in the language, which “optimized queries over objects, XML, and databases in a consistent way.” More explicitly, IQF enables “developers to express queries and updates in terms of their local programming language without sacrificing the server-side execution model of today's high-performance SQL-based approaches. Using these advances, database queries that previously were stored as opaque strings now benefit from static type checking, CLR metadata, design-time type inference, and of course IntelliSense.

The session on “Using the .NET Language Integrated Query Framework with XML Data”  indicates that “navigating, querying, and transforming XML … is both easier to use and more efficient than current XML programming techniques” and “marries the the capabilities of XPath, XQuery, and the DOM.”

Some of these features have been previously mentioned such as anonymous types (tuples) and type inference/implicit types with the var keyword. It’s obvious that tuples are used to represent table records, and the var keyword is used to avoid the cumbersome task of specifying the lengthy type names of records. These features are already familiar in some functional languages, along with lambda expressions. Lambda expressions would seem to be already available as Whidbey anonymous methods, but the emphasis on expressions in the name indicates that they can’t contain statements and probably have a tight syntax.

Other previously mentioned features are conspicuous in their absence but may actually be fully provided by the library instead of the language. I suspect this to be true for sequences; either that, or the IEnumerable interface suffices for its purposes. Type lifting through generalized member access might also have been redundant, since it can be accomplished via the unified “select” querying model. In COmega, it wasn’t clear to me that the gap between XML and relational data had been bridged as each type was accessed through generalized member access and SQL queries, respectively. Concurrency features are absent, but, then again, the mechanisms in Polyphonic C were unproven. Object initializers, which Anders suggested in place of XML literals and could have enabled DSLs in C#, are also missing in action, as are mixins, which he indicated in a whiteboard talk that the CLR team was investigating.

Some new features have come to light, namely extension methods and expression trees. Extension methods may be a general mechanism to extend the syntax of the C# language to support new domain-specific features such as SQL syntax. Expression trees may be what Erik Meijer referred to as “code literals.” This most likely allows the select and where clauses in the C# extended syntax to accept type-checked query expressions, which could later be converted to the string queries that the database engine understands, thereby eliminating runtime parsing errors and SQL injection attacks. This should be a fascinating concept, possibly enabling C# metaprogramming, so I am interested to see how this is implemented, especially since C# developer, Cyrus, calls it his favorite feature. (It may even pull him away from OCaml. Wow.)

Some other nitpicks of mine: C# 3.0 apparently doesn’t provide any syntax support for transactions, multiple-dispatch methods, covariant return types, default parameters, or generic variance.

Getting Web Services

When I left Microsoft in 2000, the overall strategy of the company had shifted to some notion of computing as “service.” It was obviously developed by executives high up and being forced-fed top down to all the product units.  This new strategy was nicknamed “.NET,” and soon every product would soon have the “.NET” suffix appended to its name in order to sound “cool.” (This ultimately caused customer confusion and was dropped from every product except Visual Studio.)

I recalled a really vague and unbelievable highfalutin vision memo of “Office as a Service,”  written by a drunk program manager, emailed to all employees in the division. The two points I got then was that Office.NET would be more connected to the Web and that future versions would be sold using an annual subscription model for “services” rendered. In the latter case, it seemed like the one-time licensing model was not sustainable over the long-term, because eventually some version of Office will have every feature that a company needs in which case no more further upgrades would needed. I saw it as a revenue ploy and really did not get the paradigm shift.

A year later into my MBA program, I vaguely heard about the “Hailstorm” initiative at the Microsoft PDC 2001 in which Microsoft would maintain all user’s information in its servers. Hailstorm never materialized because of legal barriers and its chief architect, Mark Lucosky, now works at Google after complaining that Microsoft can’t ship software. One ex-Microsoftee told me that Office 2003 invested heavily in Hailstorm and suffered from a dearth of features as a result.

Fast forward to 2002 and 2003, I increasingly hear noise about “Web services” and later “Indigo” and I keep thinking “here we go again.”

In spring 2004, I attended a DevDay session in which Microsoft introduced the concept of “smart clients.” Smart clients merged the advantages of traditional “rich clients” (desktop applications) and “thin clients” (browser applications). Smart clients are connected but offline-capable through caching. Like rich clients, smart clients utilize local resources. Like thin clients, smart clients are easily deployed and automatically updated. In addtion, smart client applications may also include versions for compact devices and/or browsers, all of which communicate and synchronize with each other through Web services. While I don’t think web services are involved, Outlook is a good example of a smart client, which is smart about online and offline network access. It’s also available on PDAs as Pocket Outlook, synchronizable through ActiveSync, and a rich AJAX online version, Outlook Web Access.

In summer 2004, I attended a couple lectures given by both eBay and Amazon employees on some of the new webservice APIs they exposed, which is when I really started to grasp the potential of webservices. I started seeing various possibilities about how I could use services in my application. I took the time to create toy applications, read and attend lectures about web services and Indigo.

A few months ago, I learned about Delicious Library. It seems that DL uses Amazon APIs to extract information such as thumbnail photos about DVDs and books. If the application also allows Amazon books and videos to be ordered from within, that would also provide a second revenue source through commissions in Amazon’s associate program. There’s probably a opportunity for an application to create a rich client front-end to all the popular e-commerce sites.

 I recently encountered the Shareware Starter Kit includes a number of common webservices for shareware developers.

Last month I played around with XML-RPC and the various blogging APIs (Blogger, MetaWeblog and MovableType). I also read up on Professional Web APIs: Google, eBay, PayPal, Amazon.com, MapPoint, FedEx, which covers web APIs from all the companies in titles plus others. While each website uses different methods such as HTTP-GET(REST), HTTP-POST, and SOAP, they all provide libraries and many of them support multiple protocols. The APIs are remarkably simple, mostly because the APIs are flat. The generic license provided by these firms usually requires a registration and also imposes a daily limit on API usage; these seem intended for business-to-business communication. Any commercial application released to consumers probably requires  direct contact with the company for more lenient licenses. While it’s possible to avoid the APIs and perform HTML-scraping to overcome vendor constraints, APIs provide a legitimate and robust approach that survives legal challenges and periodic site changes.

I eventually see myself incorporating web services in my applications, both my own and those of other companies.

The notion of “software as a service” has gradually become a coherent and unifying story throughout Microsoft. I see it in the .NET framework support for web services and ClickOnce, in Indigo’s attempts to unify the various Windows communications approaches into a simple, common services-based API, in Avalon’s borrowing of UI patterns (deployment, inductive UI, markup, navigation) from the Web. I sense it in Office 12’s continued movement towards XML and network-centric computing, and in Microsoft’s recent embrace of RSS. I can only extrapolate this to the rest of Microsoft’s divisions.

Longhorn Beta

Paul Thurott reports the Longhorn Beta 1, a developer release, slipped to late July, but screenshots of build 5203 appear to be available (yawn!) and invitations to beta testers have already been sent out. Paul maintains that feature-complete Longhorn Beta 2 will still be released on Nov 2005; most other reports indicate early next year. Beta 2 will have a new user interface called Project M. (The name reminds me of the Project X desktop UI, which Bill Gates demoed at Comdex in the mid-90s, but which never materialized.)

A lot more noise about Longhorn have been dripping in the past few weeks. In anticipation of the summer beta, the August issue of PC Magazine already has a review of build 5048 of Longhorn with some nice pictures of the explorer. (WinSupersite had a review for awhile of that build .) Pro-Networks is maintaining a list of new recent news items.

 

Shareware Industry Conference

I am heading off to the Shareware Industry Conference this week in Denver. I hope that this will be an educational experience and point me to the most efficient way to make money in the software business. I plan on spending most of my time on business-related panel and less on those related on software development and web design.

Microsoft At War With Self

Last year, Joel wrote a widely read post on “How Microsoft Lost the API War,” concluding…

Much as I hate to say it, a huge chunk of developers have long since moved to the web and refuse to move back. Most .NET developers are ASP.NET developers, developing for Microsoft's web server. ASP.NET is brilliant; I've been working with web development for ten years and it's really just a generation ahead of everything out there. But it's a server technology, so clients can use any kind of desktop they want. And it runs pretty well under Linux using Mono.

None of this bodes well for Microsoft and the profits it enjoyed thanks to its API power. The new API is HTML, and the new winners in the application development marketplace will be the people who can make HTML sing.

Last year, I attended a Dev Days conference, focused on Smart Clients, which are network-aware desktop applications that provide many of the advantages of web applications, such as automatic-updating, simplified deployment, and offline caching.

Smart clients are the precursor to future WinFX applications that eliminate much of the distinctions between Web and desktop applications. ClickOnce applications provide web deployment, automatic updates, and security. Avalon Express applications add richer installs, richer presentation, navigation, and others.

It seemed that in the battle for the hearts and minds of developers, Microsoft and rich client development was leading with upcoming Avalon and Indigo APIs. (It’s not entirely clear, since I don’t know if Avalon Express applications also supports the traditional browser model of pulling new pages from the server.).

However, muddying that view, articles began springing up earlier this year about a new generation of AJAX (Asynchronous Javascript With XML-Http) web applications being pioneered by Googles and others (even Microsoft with its Outlook Web Access).

Now, Scott Guthrie of the ASP.NET team announce the Atlas initiative, which attempts to integrate rich clients and thin clients from the other direction—offering rich desktop capabilities and caching to web applications. If so, Microsoft is preempting the Internet insurgency and there isn’t really going to be a war.

Blurring the line further, Atlas also makes some of its services available to Avalon applications, such as the Client Building Block. In fact, in this year’s PDC, ASP.NET moved from the web track in 2003 to the client track alongside Avalon.

Dynamic Typing in C#

The next iteration of C# is poised to become multi-paradigmatic, addressing numerous issues in programming. Most discussions focused on SQL and XML data integration and concurrency, but new features mentioned by a journal submission suggest an assault on dynamic languages is in preparation.

Eric Meijer and Peter Drayton recently submitted “Static Typing Where Possible, Dynamic Typing When Needed: The End of the Cold War Between Programming Languages” for a journal on “Revival of Dynamic Languages.” Both authors worked at Microsoft on research projects experimenting with new language extensions on top of C#. Their article explains how dynamic features can be retrofitted cleanly into statically typed language using examples based on C# extensions. Most of these have been published previously in articles on COmega and Spec#. The effect is pseudo-dynamic typing—dynamic style programming on top of a statically typed language. The introduction of pseudo-dynamic typing in C# raises the possibility that it may become pervasive as a scripting language, stealing much thunder away from Python, Perl and Ruby.

Is it a coincidence that the timing of this publication is so close to the upcoming PDC 2005 announcement of C# 3.0? I think not, yet at the same time I am not sure all of the features mentioned will make it in. C# 2.0, which introduced four major features, is essentially a light release in preparation for the mega-release C# 3.0, which was co-developed at the same time. (Whidbey was originally the version 1.2.) Chris Brumme, CLR architect, previously mentioned that Whidbey release was focused on product maturity, focusing on fundamentals such as performance, reliability, and security, but that the following Orcas release would embark on a lot of crazy new ideas, such as those from functional and dynamic programming languages. As an indication of this, Jim Huginin, author of IronPython, a .NET dynamic language, was recently hired into the CLR team. I’m just glad that Orcas will be such a feature-filled release, because the next version, Hawaii, will probably not arrive until 2009 or 2010.

I outlined below some of the major solutions that the paper mentioned. Some of these solutions have already been incorporated in C# or introduced in one of the research languages Spec# and COmega; in those case, I included them information within square bracket.

• Type Inference. Type inferencing is already offered in a number of languages like Haskell. Currently, type information must be specified explicitly in the declaration. With type inferencing, a variable is assigned the most general type that will successfully compile within a block. It requires an advanced AI technique called unification, already used to some degree in generic type inference in C# 2.0. Eric noted that static typing with type inferencing could result in less verbose code than dynamic typing: Within object literals, for example, constructors can be invoked without specifying the type to construct.
• Contracts. [Spec#] Contracts extends the type system to support invariants, preconditions, postconditions. Contracts allow stronger compile and run-time checks. It also opens up the possibility of long-running theorem-proving tools to examine the IL post-compilation and establish program correctness.
• Coercive subtyping
  • typelifting across collections, null types, discriminated unions and tuples. [COmega] This is essentially generalized member access, which I mentioned in an earlier post. I liked to see a systematic, orthogonal approach to enable lifting over an type, not just the specific ones mentioned above.
  • late-binding. [VB] C# may support late-binding for object variables in the same fashion VB does today.
  • (patterns). This isn’t in the paper, but a C# developer mentioned possibility that generic types may support patterns, in addition to interfaces, to allow calling member functions by “name” like C++ templates do. I suspect that, if this is implemented, patterns will be implemented as interfaces, which are dynamically painted at runtime unto an object rather the explicitly implemented at compile-time.
• Dynamic scoping. A statically typed compiler emulates dynamic scoping by passing in hidden arguments into a function that uses a dynamically scoped variable. Any function that calls dynamic scoped functions with an implicit argument will also required a hidden implicit argument as well.
• Covariance and Contravariance in Generics. [IL 2.0] Covariant and contravariant generc type parameters are already supported in IL in Whidbey, but have not yet been integrated into any of the mainstream languages.
• Adhoc relationships and prototype inheritance
  • Expando properties. C# could offer special syntax support for untyped objects, essentially variables of type Dictionary<string, object>, essentially mimicking the behavior of  Perl and Python. This support would also required reflection through the IExpando interface.
  • External link tables. Link tables could help C# bridge the mismatch between relational keys and object references.
• Lazy evaluation. Erik mentions streams of objects, which I think is partially addressed by iterators in C# 2.0, with more advanced support coming in Orcas.
• Eval. The article also looked at eval capabilities of dynamic languages. Some of the more common uses of eval can be solved through closures or standard methods for deserializing data. The more advanced uses (partial evaluation, multi-stage programming and meta-programming) would rely on support for code literals (programs within programs). No specific details were provided on this point, so it’s the least likely to be address within Orcas.

Will these features carry over to Visual Basic? Perhaps, but recent statements by various designers in the C# and Visual Basic team suggest a growing divergence in language approaches, reflecting differences in the underlying philosophies of each. While both VB and C# are adding data features to the language, it appears that each will take a separate approach mirroring their respective Mort and Elvis personas. These emerging differences will force developers in the future to reconsider the substitutability of C# and VB and take sides depending on the priorities of their application development—rapid development or code quality. (Microsoft maintains that VB, C# and C++ emphasize RAD, language innovation, and power, respectively.)

Visual Basic is all about rapid application development. It more focused on accessibility and productivity and is probably more likely to tradeoff runtime performance for the immediacy of quick background compilation and interpreter-like interactivity. This is because VB applications are more likely to be ad-hoc, internal business applications that need to be churned out quickly and inexpensively. These applications are more likely to rely on off-the-shelf components to speed development. Since they are used in a fixed manner in a fixed environment, these applications have limited testing needs.

Development in C/C++ is usually too costly for routine IT work; those languages are more cost-effective for applications developed for sale. As a mostly psychological descendent of C family of languages, C# is more focused on software engineering, and hence emphasizes explicit code and error detection at compile-time at the expense of programmer interactivity; it also competes with C++/CLI in offering easier access to the platform though unmanaged pointers—important for managing memory-mapped files, processing image and manipulating low-level system data structures. C# is used more often in commercial applications and libraries with large external customers. The higher cost in testing makes it more worthwhile for C# to trade off compilation time for time-consuming code analysis and inferencing

These aren’t hard guidelines, but reflect the different emphasis each language takes. Some good examples are new features offered to reduce code: New code-reduction features in Visual Basic seem intended to promote accessibility such as the My classes, Handles and WithEvents. In contrast, new code-reduction features in C# involve more advanced concepts (closures and iterators) and serve to eliminate the programmer from entering tedius, error-prone lines. 

Some More Entrepreneurial Fodder

Motivational presentations and essays help keep me going in my quest… I share some recent finds.

How To Make A Million Dollars. Via MicroISV, Marshall Brian, founder of How Stuff Works, gave a presentation on how to become a millionaire to Duke students, if they can’t win the lottery, inherit money, marry wealth, or sue for injuries.

How To Be Successful, Happy, Fulfilled and Drive A Totally Hot Car. Via Jeff Atwood and Steve Makofsky, the founder of Delicious Library tells how he succeeded writing Mac software, and, in the process, indicates how you can too.

You Got To Find What You Love. Steve Jobs in a Stanford commencement address last month stated to graduates, "Your time is limited, so don't waste it living someone else's life. Don't be trapped by dogma - which is living with the results of other people's thinking. Don't let the noise of other's opinions drown out your own inner voice. And most important, have the courage to follow your heart and intuition. They somehow already know what you truly want to become. Everything else is secondary."

It’s A Great Time To Be An Entrepreneur. Bnoopy says “Excite took $3 million dollars to get from idea to launch. JotSpot took $100K.” Although the analogy may be a little flawed, but the message is correct.

Small Is The New Big & More on Small. Seth Godin points out why you might small companies can out perform larger established companies.