So the CodeProject competition concerning Intel's latest Ultrabook generation is coming to an end ... After coding a lot of hours my submission Sumerics was ready to be published. Not all the planned features are included, but I am ready to submit continuous updates in the next couple of months. Right now the app is already pretty good at calculating complex numerics and visualizing it.
Missing - but only for the moment - is the graphical editor. Version 1.0.0 will certainly contain the graphical editor. Everything behind the curtain is already prepared, just the UI needs to be written and tested. Most of the work of Sumerics was actually spent on YAMP, which is becoming more and more complete. Right now YAMP can handle functions as objects. Therefore it is also possible to define own functions in a very short syntax known as lambda expressions.
Also the numerical possibilities of YAMP have been extended. That being said I am quite positive that YAMP is certainly capable of providing the basis for a lot of nice applications or being the engine in some applications that require math expressions to be parsed or evaluated.
At the community day of Microsoft Germany I attended a special kind of Windows 8 store application workshop. The workshop itself did not teach me anything new about writing Windows 8 store apps, however, with the assistance of a Microsoft Technology Evangelist I was able to to figure out some yet unknown stuff about writing Windows 8 apps.
So far I found out some positive stuff and some negative. First of all the negative sides:
- Even though writing apps is not so much different than writing WPF applications - it is actually very different (the next points will explain why!)...
- The binding engine has a (serious) bug - own classes have to be bound as
object- otherwise no binding will work (it took me many hours to figure this out).
- Reflection is different as well. Since we are working with a different version of the .NET-Framework called ".NET-Core" we will have to deal with that. At first I was quite frightened that reflection was not possible at all - but once I included the
System.Reflectionnamespace I figured out that everything is now included over extension methods.
- They also changed small objects in a way that I do not understand. A very simple example is the
Colorstructure. It is missing the static method
FromRGB(). It is no problem since there is also a
FromARGB()method, but having a simple overload would not have been difficult and make old code a lot more portable. As I said this is just a really simple example and of course one can attack this by creating an extension method - but still...
NavigationCacheis off per default. I would have expected a more intelligent setting (especially for those back buttons!) to be active by default.
This all being said I have also some really positive notes:
- Creating a really simple app can be done by just porting some code and using some of the user controls - the user controls are actually better than their counterparts from WPF or Windows forms. And right now it seems like they only focused on a few - just to push developers into the corner of just using those few. This is actually quite nice.
- The .NET-Core includes the most important stuff and some really nice to have possibilities.
Last but not least I want to announce my latest article, which will most likely be published in like 2 weeks: The way to lambda - which will give a basic overview and deep insight into using lambda expressions. There I will not only give (another) introduction to lambda expressions, but I will also go into details like:
- Do I face performance problems when using lambda expressions (with or without closures)?
- Known patterns that can be constructed with lambda expressions.
- Some new patterns I came up with that can be helpful and require lambda expressions.
- When a lambda expression makes sense and when referencing functions or not using lambda expressions is the way to go.