Lee Whitney's Blog

Startup advice and scavenger hunts

People who are interested in startups are always in need of feedback because the ideas they come up with on the first, second, or 100th iteration will probably still have lots of flaws.  Our need to constantly evolve is even codified into concepts like MVP (minimum viable product strategy).  The result is that entrepreneurs are in a constant loop of asking for and giving feedback from everyone around them. 

Most people agree such feedback loops are a good thing, but the trickier question is when should you change what you're doing based on the opinion of others and when should you ignore what you hear?  The two schools of thought I see most often argue to embrace or reject advice based on a person's resume.

Resumes win

This approach gives weight to a person's opinion based on prior experience or successes.  Many would say trust your friend's opinion more than your mother's because your friend has worked at a startup and your mother has not.  Trust Steve Job's opinion more than your friend's because he is currently the embodiment of entrepreneurial success and your friend is not.  It's a simple set of equalities:

        Your friend at a startup  >  Your mother

        Steve Jobs > Your friend at a startup 

The side benefit here is being very easy to sell to investors, partners, and employees.  You have to spend very little time convincing people of your decision with this technique.

If you ignore resumes you could lose big - remember these are (many times) extremely smart and experienced people.  

Resumes lose

The alternative recognizes that successful people can be horribly wrong and if they "just don't get the vision" can be utterly blind to a great idea.  

Some prominent venture capitalists famously got up and left during EBay's pitch because they thought  "selling antiques online" was a bad idea.  Fortune 500 execs are constantly making strategic mistakes that look obvious to others.  Many think Research In Motion is the only one who doesn't know their strategy is flawed, even though the company has been wildly successful in the past.

The corollary to this is equally dangerous - not only do big resume people easily make mistakes, people with modest credentials are constantly delivering break through ideas.   EBay's relatively unknown founder was right and a talented VC was 100% wrong.  That was literally a billion dollar decision point.

Going against the grain or against resumes in some ways is like playing the Megabucks jackpot in Las Vegas.  It's risky, many people will think you are wasting your time, but if you are actually right about something no else even understands yet, the reward could be more wealth than you could imagine for rescuing a rebel princess.

Scavenger hunts

I think the best approach frames a successful startup more like a scavenger hunt rather than what types of people are right or wrong.  To have a successful startup you must collect the right "list" of "items".  The list is the group of items necessary and sufficient for one type of startup to be successful.  The items are ideas, strategies, and information.  Therefore the goal of listening to the feedback of others should be to collect items on the list. 

The items we seek are held both by people of the highest socioeconomic status and the lowest, and we ignore either at our own peril.

Only you know what's on your list so people will try to convince you their items are valuable, but that may or may not be true.  They are usually not lying, they just have their own lists which may be different from yours.

In this analogy maybe a person's previous experience and/or "success", means that they are good at scavenger hunts.  They are good at finding and collecting items.  We should listen to these people to learn their skills and techniques.  We should realize the more different our list is from the person we're listening to the easier we can be led astray.  We should realize that in this scavenger hunt it's possible my mom is holding one of the items on the list.

Yesterday I gave advice to some friends on their startup.  I hope they can pick out which of my items are on their list and which are not.

 

 

Quantum Mechanics, Negative Entropy, and Super-fast Computers

The overlap of computer science and theoretical quantum physics grew a little today when the journal Nature published a very cool new paper from scientists in Zurich.

What entropy means to software people is usually much different than what it means thermo-dynamics people.  Turns out the concepts can be unified via a deeper understanding of quantum mechanics.

If you are a normal person you probably fell asleep reading the last two sentences.  If you're an abnornal person and are interested in things like the ultimate limits of super-fast computers, it's worth a read.

Here's an article on the paper from Science Daily. 

 

iPhone OAuth Starter Kit for LinkedIn

 

I've created a starter project for using the LinkedIn Api via objective-c and the iPhone/iOS. 

 

 

I'm sharing this because I don't know of anywhere else you can get these in one place:

• One project with OAuth, JSON, and LinkedIn Api examples integrated
• Fully functioning, add your app keys and run
• Uses JSON data, includes the fastest iOS parser available
• Does not use HTTP body, everything in Authentication header
• WebView integration, no figuring out how to mix in the UI pieces
• XCode 4.01 project

Hopefully this can save someone some time.  OAuth has 1,000 tiny details that can go wrong - and usually do when you're first starting out.

Any feedback on the project or code is welcome.

Updated 4/11/2011: Rebuilt with XCode 4.01, added icons.

Download OAuthStarterKit_iOS_1_1

 

iPhone / iPad OAuth for LinkedIn, Facebook, Twitter

Most apps these days have some kind of tie-in to a social network of sorts.  Which means your iOS code has to potentially authenticate a user to many different services.  

The good news is there is a standard for this called OAuth.  The bad news is it is one of the most error prone developer tasks I've seen recently.

OAuth is not hard conceptually like Quantum Mechanics, rather it's hard like there are a thousand little things you can do wrong that cause it not to work, and you end up spending time tracking down what little parameter is wrong by 1 character.

Normally in this situation a quick Google search will reveal lots of carefully refined libraries so you can just drop them in and go.

One problem with OAuth in finding a helper library is the major players like Facebook and LinkedIn are not implementing the standard in the same way.  For example Facebook uses OAuth 1.0 while LinkedIn uses 1.0a.  Just enough difference to require every library user to waste time finding the same subtle differences.

For iOS, I've yet to find a single OAuth library that supports all major services.  I mean out of the box without digging and tweaking for each service.  Yes I've seen things like the OAuthConsumer project and others, but again none are plug and play for the major services.

If anyone else finds one drop me a line, otherwise I'll consider releasing my own.  It's too late for me to not waste time on this, but others can be saved.

We need an open, canonical, objective-c library that makes these services codable by my 9 year old son.

 

 

 

! The Beauty of Creating iPhone Apps

Most people would agree the iPhone is pretty far ahead of Windows Phone 7; however there is a harsh irony that is only known to developers who use both platforms.  The irony is while the iPhone user experience is ledgendary, Microsoft’s development platform makes Apple’s tools look like it is from the Stone Age.

 

A few examples of developer water boarding:

 

Pointers still, really?

Pointers are all around you in Objective-C.    Garbage collection is a great productivity advance and available on both Android and WP7 for most code.   If Apple is going to use a language based on Smalltalk can we at least keep one of it’s best features?  Welcome back to non-null invalid object references. 

Nilla Wafers

Many nilla wafers = good.  Many forms of nil = bad.  The concept of a null reference is pretty well established after decades of use.  However for iOS apps you have:  Nil, nil, NULL, and NSNULL.  Yes all 4 needed for different subtle reasons and yes this alone has generated tons of posts from people trying to figure it out.  Love it.

ActiveX for iPhone

One of the nasty things about ActiveX controls was that referencing counting was a fundamental requirement to manage object lifetimes and it drove people crazy trying to master and manage it.  The iPhone platform, like ActiveX, has referencing counting as a fundamental requirement.  In both cases it is the source for many developer headaches.

We don’t need no stinking namespaces

This one is more comic relief than it is a problem.  Since objective-c does not support namespaces *every single framework method must be prefixed with NS* to avoid collisions.  So everywhere in your code is NS this and NS that.  Really this can be funny to look at.

Not all bad

To be fair I’ve been using all the preview releases of Xcode 4 and the IDE has made huge improvements and has some nice features.  For example I can set a nice bell to sound when a build is successful right from within the IDE while on Windows you have to do this in the control panel.  That’s something isn’t it?  :-)

 

Live from New York

A Surface application I’ve been working on has just gone live to the public in Manhattan, NY.  You can check it out at Bloomingdale’s in the Clinique area.

 
All the real products you see in the photo can be used interactively.  For example you can place a tube of moisturizer on the table and have it sent to your Facebook wall or e-mail.

 

 

Everything “feels” great to use – the gestures, discoverability, and design I all like personally.  Although the last statement may sound self-serving it’s really to the credit of the designers and Clinique product team.  By the end the process they really “got it” and have enabled a special experience.

 

 

 

Intel CPU vs. NVidia GPU: Video transcoding

There are some new benchmarks that imply Intel’s new CPU (Sandy Bridge) may actually match dedicated GPUs at video transcoding.

Intel today showed for the first time special new CPU instructions in action optimized for this task.  Encoding performance is a tricky business and all details are not available yet, but what we have so far is Intel looking very good.

The numbers compare standard Core i7 quad-core encoding with NVidia GPU and Sandy Bridge CPU encoding performance.  The encoders used were Handbrake (x264) for Core i7, Badaboom for NVidia’s GTX 260 GPU.  The Sandy Bridge encoder is not known but Intel maintains its own encoder so it may be a special version optimized for Sandy Bridge.

*Units are seconds of source video, not frames

 

 

The source and target video profiles were respectively 1080p and iPhone 480x320.

 

Grains of Salt

Now for the caveats and uncertainties that must be understood to put these numbers in context.  Consider the above numbers rough comparisons for reasons including the following:

• The encoder settings and output quality are not known to be equivalent.  This can make a massive difference in results.

• I did not run the benchmarks myself.  The Core i7/Badaboom numbers come from overclockersclub, and the Intel benchmarks were timed by Anand Lal Shimpi on his watch from the audience.

• We don’t know the exact clock speed and turbo mode for the Sandy Bridge demo.  It could be a mid-range model or a high-end extreme equivalent.

• X-Factor: The x264 encoder runs on CPUs only and it is widely considered the best encoder available.  On their team are some insane geniuses who seem to be able to optimize almost anything.  So if Intel's encoder is fast, the x264 version will likely be even faster.

Caveats not withstanding we are gettting a glimpse of the CPU/GPU video encoding battle shaping up here.  For a company like Badaboom the final results could determine their entire viability as a going concern.  For NVidia GPU encoding has been the poster child for one of the most mainstream uses of general purpose GPU computing.  For Intel it’s about staying relevant for more workloads in a new era of massively parallel computing.

The Verdict

So what do you think, will Badaboom or NVidia be hurt by Sandy Bridge?  Or is it too little too late for Intel in the encoding battle?

The final answers will start to unfold when official Sandy Bridge review samples arrive before the end of 2010.

 

Nit-picking Google Chrome UI Design

What is the worst part of Chrome's user interface design?  There is one candidate I'd like to nominate.

The user interface to change the default font in Google's Chrome browser makes me cringe. To see if you agree, here are the basic steps a user follows to change the font:

1)    Wrench = Settings?

To change something in Chrome first requires you figure out that clicking the wrench icon is how to change browser settings.  For a computer savvy person ok, I'll buy this, but for many people I know (my parents included) this has already failed.  I totally get the reason behind this - Minimalist design is aesthetically pleasing and the lack of clutter on average can provide a better user experience.  However even when this philosophy works it's still going to have trade-offs and this case is one of them.   Overall I don't begrudge Google the choice of wrench in the spirit of simplicity.  It's a trade-off (like all designs require) but even good trade-offs have their negative side.

2)    Under the Hood is Scary

Once you get to the Chrome options the next step in changing the default font is to select a tab called "Under the Hood". 

Seriously? 

It seems a bit ironic that these correlations exist:

Need big font  >  Have poor vision >  Vision degrades with age > The older you are the less likely you want to click on features called Under the Hood

Maybe to change the default font they could make you click "Stick a fork in my eye…" Usability would probably be about the same, but it might add a little variety to the experience.

3)    Web Content is Meaningless

Users making it this far will find the font settings to be categorized under "Web Content".  At first this might seem reasonable.  On second thought almost anything in Chrome could be shoehorned into this category - it's a web browser for the love of...!  It's entire purpose is to help you with web content.  My only idea on how it could be more over-generalized would be if the category was "Internet Stuff".

4)    Eliminate Scrolling by Using Tabs which Require Scrolling

The final step to finding the default font settings is to realize that you must scroll down within the Under the Hood tab before you can see anything related to fonts.  The first problem with this is some designers just consider it bad design to scroll too much within tabs because one of the main reasons for the tab metaphor was to reduce the need for scrolling (run-on sentence intentional). 

Recapitulation

Changing the font in Chrome fails at least two common usability benchmarks.  First, it will often fail the parent test (unless your parents are fairly software savvy).  Second, the discoverability is really poor.

Discoverability isn't everything as Scott points out, however it shouldn't suffer any more than is necessary for a balanced experience.  Could some of the steps above be made more discoverable without hurting the overall balance of feature priorities?  It doesn't seem difficult to do.

Some may say, if you hate Chrome so much just quit using it!

However I don't hate Chrome - in general I respect the work Google has done.  To be fair, this is one small feature within a vast body of design and engineering.  Regardless of my feelings though I'm compelled to use all browsers - developers are commonly using a variety of browsers for testing, research, etc.  This is not likely to change, just like my vision is not likely to improve.

Performance of Water Simulation with Hardware Acceleration using Microsoft Frameworks

I’ve found that creating water effects that respond interactively and smoothly is not really something easy to do in WPF or Silverlight.  However because a project required it I trudged forward managed to get it working pretty nicely – buttery smooth and low CPU utilization.

The results can be seen in the video, but the reasons it wasn’t easy may be interesting to WPF/Silverlight developers so I’ll mention why below.  Can you guess what the technical obstacles are?

                              (user interaction 17 seconds in)

                              (user interaction 17 seconds in)

Graphics architecture

The first hurdle is that WPF and Silverlight primarily use a “display list” or “retained mode” graphics architecture.  This is usually not a bad thing, and allowed developers to break away from the WM_PAINT model which is used in WinForms and Win32 before that.  Those older systems encourage an “immediate mode” architecture while WPF and Silverlight encourage a retained mode, but will tolerate immediate mode in certain cases.

WPF and Silverlight

You might have nightmares about WinForms and Win32 and wish all manner of death upon them.  Death to immediate mode as well – long live WPF/Silverlight and retained mode graphics! 

Just one small problem – immediate mode graphics are well suited to certain things like games and simulations, and no one wants give those up.  In fact Direct3d itself is an immediate mode architecture which underlies most graphics in Windows 7 including WPF itself.  I’m speaking in general here and there are always exceptions.  For example I’ve written simple games and simulations in WPF, but many times it is not an ideal approach.

Animation vs. Simulation

To get more specific on why WPF/Silverlight are not great at simulating water, it’s basically about loops.  Many simulations for water and other phenomena run a programming loop over and over again throughout the simulation.  The reason is that future states of the simulation depend on the output of previous states of the simulation.  The problem is that animations are different than simulations.

In WPF you can easily animate a ball along a flat line.  WPF determines the position of the ball using a function with time as the input:

• Time elapsed 1 second  -   Move ball to 25% along the line
• Time elapsed 2 second  -   Move ball to 50% along the line
• Time elapsed 3 second  -   Move ball to 75% along the line

You could also choose any random time and the ball would be placed properly because the new position does not depend on the previous position.  It’s always just a function taking any time as an input, and spitting out a position as output.

Most animation systems work in a similar way, which is why regardless of what applications artists and animators choose it usually has a big timeline along the bottom.

So if that's how animation works, how is simulation different? 

In simulation of water our function to calculate the new position takes not only time as an input but also the previous position of the water.  This feedback loop is the key difference.

Since WPF does not encourage loops that let you feedback the output into the next input, we are kind of stuck.

What about CompositionTarget?

One ray of hope is the CompositionTarget.  This is a WPF component specifically designed to enable controlling your own rendering loop.  I consider CompositionTarget going a bit off the reservation because it’s not really a mainstream technique used by most apps, however it’s fairly clean and that’s ok if it can get us past the loop barrier.  While this lets us have precise control over the rendering loop, it still does not allow any way for output of the shaders to feed back into the loop.  

We could just not use shaders and write the code procedurally, but then the question becomes how much performance do shaders afford our simulation?

How fast are shaders in WPF?

VERY fast.  In fact to get nice performance and realistic water, custom shaders are essentially required.  It's an order(s) of magnitude difference.  Using shaders should be no problem because WPF supports shader model 3.0.  In fact in a previous blog post I showed a single drop water effect using WPF shaders and the code is simple XAML with no problems.  But again, that was an animation not a simulation.  The drops could not affect each other and you could not drag your finger through the water and create a wave as in the video above. 

To get some real coolness we need a simulation, which means using the output from the shader as the input for the next time the shader is run.  The problem is when you capture the output of shaders as data in WPF (rather than just display the output), you lose hardware acceleration and performance goes to heck in a handbasket.  One item on my wishlist for WPF 5.0 would definitely be enabling a form of shader trees where the output can be modified and looped back as input.

To keep pixel shaders running in hardware in this fashion within a WPF app requires Direct3d, which in turn requires D3DImage.  D3DImage is the class that can allow separate Direct3d C++ code to output into an image brush within a WPF app.  It also allows (requires really) the Direct3d code to have it’s own rendering loop, which allows us to feed shader output back to the input for the simulation.

With Silverlight its worse because of the lack of GPU acceleration and because the Direct3d integration is not an option.  I’ve seen a few liquid/particle simulations in Silverlight but they are quite slow, and tend to peg CPU utilization. 

So the bottom line is to create interactive effects like this in WPF really requires CompositionTarget, custom shaders, and a separate Direct3d helper DLL.  The first two techniques alone will do the same thing at about a quarter of the speed.

Every year I hope to never code in C++ again, but it looks like that time is not here quite yet.

 

WPF Water drop shader effect

This video shows a water drop effect implemented using WPF animations and a custom shader.  It's written using .NET 4.0 in which support for shader model 3.0 was added.  You could probably do the same thing in .NET 3.5, but it's a pain having shader instructions limited to 128 or whatever the limit was.  It could pretty easily run in Silverlight 3 or later with the usual WPF->Silverlight mods.

There are two parts to achieving this effect, the shader and the animation.  The shader is the canonical ripple effect and is common enough I won't post it here.

However I've posted animation below - it may be helpful because you have to tweak things a bit to get a more organic look.

The objects are bouncing off one another using a simple physics model I added based on the Farseer engine.

Note one of the objects is a working analog clock which continues to run while the water drop falls on it.  One final trivia:  The coin is a $3 gold piece that was in circulation sometime around the late 19th century.  It's worth a bit more than $3 now ;).

This is the shader animation, just throw it in a resource dictionary and fire off a trigger on mouse or other event:

        <Storyboard x:Key="waterDropStoryBoard">
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Amplitude"
                    BeginTime="00:00:00" >
                <LinearDoubleKeyFrame KeyTime="00:00:00"  Value="0" ></LinearDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Amplitude"
                    BeginTime="00:00:00" >
                <LinearDoubleKeyFrame KeyTime="00:00:00.25"  Value=".25" ></LinearDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Amplitude"
                    BeginTime="00:00:00.25" >
                <EasingDoubleKeyFrame KeyTime="00:00:03"  Value="0" >
                    <EasingDoubleKeyFrame.EasingFunction>
                        <CubicEase></CubicEase>
                    </EasingDoubleKeyFrame.EasingFunction>
                </EasingDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Frequency"
                    BeginTime="00:00:00" >
                <LinearDoubleKeyFrame KeyTime="00:00:00"  Value="0" ></LinearDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Frequency"
                    BeginTime="00:00:00" >
                <LinearDoubleKeyFrame KeyTime="00:00:00.25"  Value="100" ></LinearDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Frequency"
                    BeginTime="00:00:00.25" >
                <EasingDoubleKeyFrame KeyTime="00:00:03"  Value="0" >
                    <EasingDoubleKeyFrame.EasingFunction>
                        <CubicEase></CubicEase>
                    </EasingDoubleKeyFrame.EasingFunction>
                </EasingDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Phase"
                    BeginTime="00:00:00" >
                <LinearDoubleKeyFrame KeyTime="00:00:00"  Value="0" ></LinearDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
            <DoubleAnimationUsingKeyFrames
                    Storyboard.TargetProperty="(UIElement.Effect).Phase"
                    BeginTime="00:00:00" >
                <EasingDoubleKeyFrame KeyTime="00:00:03.0"  Value="20" >
                    <EasingDoubleKeyFrame.EasingFunction>
                        <CubicEase></CubicEase>
                    </EasingDoubleKeyFrame.EasingFunction>
                </EasingDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
        </Storyboard>