I gave a speech there about the “Intel AppUp Developer Program: the New App Store for Netbooks and Tablets” explaining the opportunities for developers when they submit their products in the AppUp Developer Program. In a short example I showed how an existent program can be prepared to be released inside the Intel AppUp app store. Download the PowerPoint presentation.

Did you attend the European Software Conference this year, too?

Beside parsing and evaluating a formula with all common mathematical functions (like sine, cosine, logarithm, …), I additionally needed to be able to use variables inside the formulas.

The best solution that I found is this one here:
http://www.lundin.info/mathparser.asp

The usage is very easy; here you can see a C# example code:

// Instantiate the parser
ExpressionParser parser = new ExpressionParser();

// Create a hashtable to hold values
Hashtable h = new Hashtable();

// Add variables and values to hashtable
h.Add("x", 1.ToString());
h.Add("y", 2.ToString());

// Parse and get the result
double result = parser.Parse("xcos(y)", h);

And for those of you that prefer Visual Basic .NET:

' Instantiate the parser
Dim parser As New ExpressionParser()

' Create a hashtable to hold values
Dim h As New Hashtable()

' Add variables and values to hashtable
h.Add("x", 1.ToString())
h.Add("y", 2.ToString())

' Parse and get the result
Dim result As Double
result = parser.Parse("xcos(y)", h)

It is important that the values are always added as String to the hashtable of variables. The reason is that internally it just injects them into the formula before parsing it – this way they have to be of type String, obviously.

The free assembly is open source and under the LGPL license. Therefore it can also be use in commercial projects as long as it is only linked dynamically as external library.

Let’s start with a code listing and then I’ll explain what I’m doing here:

const double frequency	= 1000;
const double amplitude	= 20000;
const long sampleRate	= 44100;
const int durationSec	= 5;

long sampleCount = sampleRate * durationSec;

double timeStep = 1.0 / (double)sampleRate;

double time = 0;
int[] values = new int[sampleCount];
for (long i = 0; i < sampleCount; i++) {
	values[i] = (int)(amplitude * Math.Sin(2 * Math.PI * frequency * time));
	time = time + timeStep;
}

OK, here are some explanations:

• lines 1-4: some constants you can change to e. g. adjust the frequency.
  Note: the frequency cannot be more than half the sampling rate.
• line 6: calculating the number of sampling points.
• line 8: calculating the time between two sampling points.
• lines 10-11: some variable initializations.
• lines 12-15: here finally the value of each sampling point is calculated.

And here is the corresponding code for Visual Basic .NET:

const frequency as double		= 1000
const amplitude as double		= 20000
const sampleRate As Long		= 44100
const durationSec As Integer	= 5

Dim sampleCount As Long
sampleCount = sampleRate * durationSec

Dim timeStep As Double
timeStep = 1.0 / sampleRate

Dim time As Double = 0
Dim values(0 To sampleCount - 1) As Integer
For i As Long = 0 To sampleCount - 1
	values(i) = amplitude * Math.Sin(2 * Math.PI * frequency * time)
	time = time + timeStep
Next i

For sound playback you can now use either an API call like PlaySound (of winmm.dll) or the solution of this great article.

Did you also need to generate a sine in .NET yourself already?

• English
• French
• German
• Spanish

As I do have a lot of German apps, too, I’ll start to submit them to AppUp now. Obviously there won’t be much downloads of the German apps at the moment, because Intel needs to fill the store with apps first, before they can start to distribute the store to end customers. But I’m confident that when distributed there will be good download counts as for the English system then.

But what the heck is “MeeGo”?

Yes, I also did not hear about this operating system before. So let’s see what the MeeGo webpage itself tells us about this system:

The MeeGo project provides a Linux-based, open source software platform for the next generation of computing devices. The MeeGo software platform is designed to give developers the broadest range of device segments to target for their applications, including netbooks, handheld computing and communications devices, in-vehicle infotainment devices, smart TVs, tablets and more – all using a uniform set of APIs based on Qt. For consumers, MeeGo will offer innovative application experiences that they can take from device to device.

OK, so basically MeeGo is (yet) another platform for netbooks, tablets and other mobile devices. But Intel really is focussing on pushing this new platform and we’ll see how much success it will have at the end.

Anyway, I’ll try to port at least one of my apps to this new system – just to see how it works.

Did you tried MeeGo yourself already or even published an app for it?

Especially the exchange of experiences with other developers was great – I’ll be at the ESWC in 2011, too!

Intel AppUp is an app store for netbooks and tablets. The user can directly download, install and – in case of paid apps – buy products from the AppUp app store.

But why Intel thinks it will be successful with yet another app store?

Of course, there won’t be many people that download the AppUp client software that is necessary to use the app store from the AppUp webpage. But in cooperation with Intel’s hardware partners the AppUp client will get pre-installed on many netbook and tablet devices. That’s the way Intel will spread this client to as many users as possible.

But why that’s interesting for me as a developer?

I’m always searching for a new distribution channel for my products and as it’s very easy to get an app into the AppUp store, I’ll just try that.

More about that and the validation process in another post.