I have taken Autodesk SoftImage for a test drive. Up to now, I have been using 3DS MAX 2013 for modelling and rendering. I must say, I have a feeling that I might replace 3DS MAX with SoftImage – the way that SoftImage exposes its tools to modify geometry seems very intuitive to me.
I am very excited to learn this great tool – think it wil be awesome. I still have ALOT – well, EVERYTHING – to learn. But the little I did learn so far impressed me quite a bit.
Struggling, that’s where I am. It is not simple. Year after year after year… I am struggling. But am I making progress? I believe I am. Slowly – painfully slowly - but surely. Do I still believe that truly intelligent machines are possible? I know so baby!
I learnt the following today: it is very important to understand the concepts of copyable and non-copyable (but movable) types in C++11.
Modern C++ encourages the use of smart pointers over raw pointers whenever possible. So let’s say you have a class A, and another class, class B. Let’s also say that class A has a vector of pointers to class B, like this:
std::vector<CB*> m_Bs;
Improving this to use the unique_ptr smart pointer, we have:
std::vector<std::unique_ptr<CB>> m_Bs;
OK. All well and good. But now let’s say that in class A we have a method called AddB(), in which we want to add a CB to this vector. We might write this:
void CA::AddB()
{
auto newB = std::unique_ptr<CB>(new CB());
m_Bs.push_back(newB);
}
This is a good try – but it won’t compile! The reason why it won’t compile demonstrates the nature of unique_ptr very well. unique_ptr is not copyable, because it is unique – there can only ever be a single reference to it. What you are telling the compiler to do in the above code snippet, is to create an instance of a unique_ptr to CB and store it in the variable newB. This is cool – no problem. But – and this is what I learnt today – be careful when passing newB to functions as parameters! Function parameters are COPIED to the function. But unique_ptr is not copyable.
So how to fix this? Well luckily that is easy: we destroy the local (newB) instance of the unique_ptr and MOVE it to the vector. This is done by simply using the std::move method, like so:
m_Bs.push_back(std::move(newB));
And now this compiles because the copy constructor of newB, which is illegal because it is an unique_ptr, has not been called.
Beautiful!
OK, cheers.
As of today, my Farve Artificial General Intelligence system now has a new name; the TR Artificial Intelligence Platform. It is time for a name change. I was playing with some new names for a while, including Athena and Hephaestus (http://en.wikipedia.org/wiki/Hephaestus). But today, I settled on TR. Strangely maybe, it is not an acronym, it is just TR. I don’t know why – the name just came to me :).
I have bought myself a massive book, “Professional C++ – Second Edition”, and I am working through it. I have also downloaded and watched various talks covering C++11 and WinRT, from the Microsft BUILD converence that was held in Anaheim, California. I watched presentations by people like (the legendary) Herb Sutter. I have consequently started to re-write my whole Farve artificial intelligence system in C++.
One word: C++ has always been the best, and with the new language features in C++11 it is not just still the most efficient programming language in the world, but it has native support for all the modern concepts found in ‘higher-level’ languages like C# – properties, delegates, events, lambdas… not to mention the library objects it had for long now in the STL, things like shared_ptr…
OK that was not one word, it was one paragraph though. C++ is back baby. And now also with the MOST powerful support for WinRT programming (the Windows Runtime – it truly is, as Microsoft say – a bold new reimagining of Windows). Oh yes, and C++ AMP – Accelerated Massive Parallelism – writing code that runs tens or hundreds of times faster, on DirectX hardware… it is.. beautiful.
There is little doubt in my mind – my language of choice is C++ again. The ease of C# – any monkey can code in C# – has for a time lured me away from my first love, which is C++. But now I feel guilty for having left.
Don’t get me wrong – .NET is nice. It is very nice!
But nice is just… nice. C++ is more than ‘just nice’. And C++11 is, as of this writing, the best programming language there is, IMHO.
As Herb Sutter kept pointing out in his presentations – C++11 is Clean, Safe, and Fast.
And I am very impressed with the details of Windows 8! It is really impressive. The WinMD (Windows Metadata – which makes the whole Windows Metro API available to ANY language – hence the ability to use JavaScript, for example) is great. The new object-oriented API, with namespaces and interfaces etc, is great. The language projections are great. Oh and the native support in Microsoft C++!! for the WIndows Runtime, and the fact that C++ is IDEAL for it (since it is, at the core, an extension of COM), is great.
So much to learn!!
Success 
Hello, readers.
I have not posted here for a very long time, my apologies for that.
So, what is new in my life? Not much, it is still mostly boring. But I can write a few words.
I find that in this time of the Christmas feeling starting to come again, I sometimes think of Lorena. I find that I miss her, then it changes to anger because of her deception, then it turns to worry (since I just never heard of her, some part of me will always wonder if maybe something bad happened to her, instead of she just leaving me). Anyway, she is thoroughly in my past. I hope to soon meet someone special again.
I have started a new technical document for Farve, my artificial intelligence. The document is titled “Principles of Intelligent Systems”. It is where I accurately document my EXCON neural network architecture for now – later I will add details pertaining to other aspects of Farve (non-neural-network aspects). But EXCON is the big one to get right now. I have proven that the concept works – now I am refining it and building something functional.
I am going on leave soon! I am very tired and stressed, this has been a tiring year for me. I look forward to my holiday. I am going to party December away !!!!
The end of the world is next year. So I hope y’all enjoy the little time we have left. As a species, we did not get very far hey? We are going to go extinct next year, and we have not even achieved interstellar travel, or colonised another planet. That sucks!
http://news.nationalgeographic.com/news/2009/11/091106-2012-end-of-world-myths.html
Cheers!
By Steve Rowe:
The Windows Runtime is exposed using API metadata (.winmd files). This is the same format used by the .NET framework (Ecma-335). The underlying binary contract makes it easy for you to access the Windows Runtime APIs directly in the development language of your choice. The shape and structure of the Windows Runtime APIs can be understood by both static languages such as C# and dynamic languages such as JavaScript. IntelliSense is available in JavaScript, C#, Visual Basic, and C++.
In short, Windows Runtime is a new set of libraries exposing Windows functionality and available to JavaScript/C#/VB/C++. Each language has been made to understand and be able to call them directly rather than having to go through some thunking layer.
Silverlight and WPF are flavors of XAML that run on the CLR. Among other functionality, Windows Runtime exposes a version of XAML very similar to Silverlight, but does so in a native way, not via the CLR. It can be accessed from the CLR, but also from C++.
I have been studying this for a couple of days, it can be confusing at times. The reason is because programming languages are often part of the discussion. I found the following explanation of WinRT, by Pavel Minaev – I think it is a very good explanation.
———-
At the lowest level, WinRT is an object model defined on ABI level. It uses COM as a base (so every WinRT object implements IUnknown and does refcounting), and builds from there. It does add quite a lot of new concepts in comparison to COM of old, most of which come directly from .NET – for example, WinRT object model has delegates, and events are done .NET-style (with delegates and add/remove subscriber methods, one per event) rather than the old COM model of event sources and sinks. Of other notable things, WinRT also has parametrized (“generic”) interfaces.
One other big change is that all WinRT components have metadata available for them, just like .NET assemblies. In COM you kinda sorta had that with typelibs, but not every COM component had them. For WinRT, the metadata is contained in .winmd files – look inside “C:\Program Files (x86)\Windows Kits\8.0\Windows Metadata\” in Developer Preview. If you poke around, you’ll see that they are actually CLI assemblies with no code, just metadata tables. You can open them with ILDASM, in fact. Note, this doesn’t mean that WinRT itself is managed – it simply reuses the file format.
Then there are a number of libraries implemented in terms of that object model – defining WinRT interfaces and classes. Again, look at “Windows Metadata” folder mentioned above to see what’s there; or just fire up Object Browser in VS and select “Windows 8.0″ in the framework selector, to see what’s covered. There’s a lot there, and it doesn’t deal with UI alone – you also get namespaces such as Windows.Data.Json, or Windows.Graphics.Printing, or Windows.Networking.Sockets.
Then you get several libraries, which are specifically dealing with UI – mostly these would be various namespaces under Windows.UI or Windows.UI.Xaml. A lot of them are very similar to WPF/Silverlight namespaces – e.g. Windows.UI.Xaml.Controls is closely matching System.Windows.Controls; ditto for Windows.UI.Xaml.Documents etc.
Now, .NET has the ability to directly reference WinRT components as if they were .NET assemblies. This works differently from COM Interop – you don’t need any intermediate artifacts such as interop assemblies, you just /r a .winmd file, and all types and their members in its metadata become visible to you as if they were .NET objects. Note that WinRT libraries themselves are fully native (and so native C++ programs that use WinRT do not require CLR at all) – the magic to expose all that stuff as managed is inside the CLR itself, and is fairly low level. If you ildasm a .NET program that references a .winmd, you’ll see that it actually looks like an extern assembly reference – there’s no sleight of hand trickery such as type embedding there.
It’s not a blunt mapping, either – CLR tries to adapt WinRT types to their equivalents, where possible. So e.g. GUIDs, dates and URIs become System.Guid, System.DateTime and System.Uri, respectively; WinRT collection interfaces such as IIterable and IVector become IEnumerable and IList; and so on. This goes both ways – if you have a .NET object that implements IEnumerable, and pass it back to WinRT, it’ll see it as IIterable.
Ultimately, what this means is that your .NET Metro apps get access to a subset of the existing standard .NET libraries, and also to (native) WinRT libraries, some of which – particularly Windows.UI – look very similar to Silverlight, API-wise. You still have XAML to define your UI, and you still deal with the same basic concepts as in Silverlight – data bindings, resources, styles, templates etc. In many cases, it is possible to port a Silverlight app simply by using the new namespaces, and tweaking a few places in code where the API was adjusted.
WinRT itself doesn’t have anything to do with HTML and CSS, and it bears relation to JavaScript only in a sense that it is also exposed there, similar to how it is done for .NET. You don’t need to deal with HTML/CSS/JS when you use WinRT UI libraries in your .NET Metro app (well, I guess, if you really want to, you can host a WebView control…). All your .NET and Silverlight skills remain very much relevant in this programming model.
———-
Very exciting stuff.
One thing I would like to know is, how does WinRT performance compare to .NET? WinRT is not managed, so I suspect it will be slightly faster than .NET. Is that the case? Will a C# application that targets WinRT run faster than a C# app that targets .NET? Is a C# app that targets WinRT unmanaged now, or is it still managed? That is my question.
Cheers.
I am thinking about introducing genetics into Farve neural networks, and it occured to me that genetic mutation can be regarded as a form of a randomized brute-force searching algorithm. Think about that and let me know what you think.
Cheers for now.
Oh, hey Gabriella – it was nice to see you at Tings an’ Times last night! I was very surprised to see you – speechless actually. I mean, what are the chances? Based on how seldom I go out, very very slim. Chance – a interesting topic.
