Archive

Posts Tagged ‘c#’

Porting Apache Avro into .NET Core

September 7, 2016 Leave a comment

We are from Geekseat has been used Avro extensively. Currently our project needs to be done on .NET core so .As i post previously i’m working on porting Apache Avro into .NET Core. Basically there are two Avro library available. One from Apache and one from Microsoft. I want to port both of library as that has been used a lot in big data application.

Let’s get back to Apache Avro.

There are two main problem that made headache when porting this one. One is AppDomain and IL Generator / Dynamic method is missing.

appdomainmissing

dynamicmethod

Both problem exists in the ObjectCreator.cs. This class is responsible for dynamically creating object on the fly based on the avro type.

ILGenerator has been known as the fastest object creator by Ayende Research. So i think this can be replaced with Expression tree but not sure how. Then i remember that Zeddy Iskandar has been create a forum post on how to create object with expression tree with constructor. You can see the method from this forum post. Here’s the complete source code of the ctor delegate.

One down, one more to go.

AppDomain has also been solved by Michael Whelan. Here’s the blog post around how to replace AppDomain.

I use the polyfill approach from that blog post. You can see that in action here.

After fixing both problem i’ve got 382 test passed and 6 failing. I’m quite happy with this result, declare victory and push that to repository. Thanks Zeddy and Michael.

test_passed

Cheers

 

 

Advertisements
Categories: .NET, net core Tags: , , , ,

Zookeeper C# Client with IKVM .NET

September 27, 2014 Leave a comment

Why ?

A lot of big data technology created with JVM. The language are vary from plain old Java, Scala and Clojure. There are a huge number of Apache project for this kind of stuff. The infrastructure for building a serious data product is amazingly mature in Java world.

The server is in Java . Ok. fine. But do we have to code in Java too ? At least as a client using the server ?. I know that JVM is awesome, but the language is not so well compare to C#. Especially the latest one C# 5. But for now we have to admit that .NET world is very lack of Server solution.

I always try to find a client library in C#/.NET but seems that it’s not really mature or has been already dead before birth. I will give you an example for this one.

 

Zookeeper is for the distributed zoo

Zookeeper has been used as a distributed process control. If you still remember the operating system 101 about process, threads, inter-process communication so this one should be easy for you to learn. If you familiar using lock or any synchronization mechanism like mutex, semaphore etc, just think this as way to do to coordinate multiple server synchronization. And it’s only expose a simple primitive like a file system. This is amazing and flexible. At the same time also make you do a lot of works to get the stuff working.

image

So we know that Zookeeper is good, it used by a lot of big data technology like Storm, Kafka, etc. So we need to find a client library to use it right ? Good luck finding it for .NET. There are a couple of library for doing that stuff but it’s either old or not up to date.

A couple of sample of that kind of library is :

https://www.nuget.org/packages/ZooKeeper.Net/

https://www.nuget.org/packages/ZooKeeperNet/

https://github.com/devhong/Zookeeper.Net

Read more…

Xamarin and Mono … You are rock !

May 4, 2013 Leave a comment

I’ve known Mono quite a couple years ago but I didn’t really have a chance to try it out and dig deeper into this stuff. Honestly, when I hear about it, I’m a lil bit skeptical about it. Because back in the day, the implementation is very very incomplete. But now everything is change. And I’m ready to change my opinion too about that. This would be fun.,

Previous week I’ve been playing around and try some nice toys called Xamarin. Do you know what it is ? That’s make c# developer comes true ! You transition to become a mobile developer is very very smooth. Your learning curve is small. Easier to made a great apps and make money of course. Check their website and try it yourself.

 

image

 

If You love c# so bad. You praise Visual Studio a lot. This stuff is for you ! About last week ago they held a developer conference called Xamarin Evolve. I think they will upload this website soon. Check it regularly.

image

Fortunately channel9 able to interview Miguel de Icaza. This interview is amazing. He is a brilliant guy behind Mono and Xamarin.

image

And the things that made Xamarin posible is Mono. I will talk about it later in this blog.

Stay tuned !

Cheers

LINK : fatal error LNK1123: failure during conversion to COFF

December 7, 2012 Leave a comment

Yesterday I’ve got a strange error while compiling an old C modules for Apache web server. It show this error.

image

After googling I’ve found the solution in stackoverflow.

LINK : fatal error LNK1123: failure during conversion to COFF: file invalid or corrupt after installing VS2012 release preview

 

Yes. I think that’s the problem. The problem appear because I’ve installed Visual Studio 2012 in my machine. The solution is very simple. Just disable incremental linking.

image

After that you will see the problem solved.

 

image

 

Cheers

Elements of Modern C++ Style

March 4, 2012 1 comment

Sumber : http://herbsutter.com/elements-of-modern-c-style/

Artikel berikut diambil dari blog Herb Sutter yang menjelaskan mengenai hal-hal yang perlu kita ketahui bersama dalam menulis code c++ dengan cara yang baru seiring dengan disahkannya standar c++11 oleh komite ISO C++.

Ada perubahan yang minor dilakukan oleh penerjemah dalam artikel ini dalam hal penyampaian. Saya berusaha agar perubahan tersebut tidak mengubah arti dari keseluruhan artikel tersebut.

C++11 seperti bahasa baru – Bjarne Stroustrup

Standar c++11 menawarkan banyak fitur baru yang bermanfaat. Artikel ini menitik beratkan secara spesifik untuk fitur baru yang membuat c++ menjadi bahasa baru dibandingkan dengan c++98, karena

  • Standard ini mengubah gaya dan idiom yang kita gunakan dalam menulis kode C++, termasuk cara merancang library c++. Kita akan melihat banyak pengunaan parameter smart pointer, return value dan fungsi yang mengembalikan object besar dengan value.
  • Standard akan digunakan menyebar sehingga anda akan melihatkan hampir disetiap contoh kode. Salah satunya, hampir setiap code program akan dimulai dengan keyword auto pada deklarasinya

Fitur yang lain dari c++11 tentu saja sangat bagus. Tetapi diharapkan anda terbiasa dengan hal-hal yang dikemukakan disini pertama kali, karena hal-hal berikut merupakan yang lazim digunakan untuk menunjukan mengapa kode c++11 bersih, aman dan cepat – sepadan dengan code yang ditulis dengan bahasa pemroraman mainstraim lain. Ditambahkan lagi kemampuan c++ yang dapat langsung mengakses hardware, performance yang tidak dimiliki bahasa modern lain, membuatnya lebih kuat dari semula.

Catatan:

  • Seperti Strunk & White, halaman ini berfokus pada panduan dan kesimpulan singkat. Tidak ditujukan untuk menjadi sumber utama dari analisa kekurangan dan kelebihan dan hal yang detil. Hal tersebut akan dibahas pada artikel lain
  • Dokumen ini adalah dokumen yang hidup. Sehingga akan terus menerus diperbaharui dan di revisi.

auto


Gunakan auto jika memungkinkan. Ada dua alasan utama. Pertama, kita tidak perlu repot lagi mengulangi nama tipe yang sudah kita tentukan dan diketahui oleh compiler.

// C++98
map<int,string>::iterator i = m.begin();
double const xlimit = config["xlimit"];
singleton& s = singleton::instance();

// C++11
auto i = begin(m);
auto const xlimit = config["xlimit"];
auto& s = singleton::instance();

Kedua, lebih nyaman lagi jika kita tidak mengetahui tipenya atau sulit dituliskan, seperti tipe dari fungsi lambda pada umumnya, dimana kita tidak dapat menuliskannya dengan mudah.

// C++98
binder2nd< greater > x = bind2nd( greater(), 42 );

// C++11
auto x = [](int i) { return i > 42; };

Perhatikan bahwa dengan menggunakan auto, makna dari kode tersebut tidak berubah. Code tersebut tetap statically typed dan tidak berubah menjadi dynamic typed. Dan tipe dari setiap ekpresi menjadi jelas, c++ tidak lagi memaksa kita untuk menuliskan nama tipe berulang ulang.

Beberapa orang pada mulanya takut untuk menggunakan auto, karena merasa ada kemungkinan bahwa tipe yang dikembalikan berbeda dari yang diharapkan. Jika anda ingin secara eksplisit memaksa konversi dari tipe, tidak masalah, anda bisa menyebutkan tipe targetnya. Tetapi untuk bagian yang lain diharapkan anda menggunakan auto saja. Cukup jarang ada situasi kita mendapatkan kesalahan tipe yang berbeda. Dan masih tetap strong static typing maka compiler akan mengingatkan anda jika anda karena kita berusaha memanggil fungsi atau variable yang tidak dimiliki oleh tipe tersebut.

Smart pointer : No Delete

Selalu gunakan smart pointers, dan non-owning raw pointers. Jangan gunakan owning raws pointers dan delete, kecuali di kasus langka dimana anda harus mengimplementasikan struktur data sendiri( meskipun demikian anda harus tetap menjaganya terenkapsulasi dalam batasan kelas)

Jika anda mengetahui bahwa anda hanyalah satu-satunya pemiliki dari object lain, maka gunakan unique_ptr untuk menujukkan kepemilikan tunggal.

Ekspresi “new T” seharusnya langsung menginisialisasi object lain yang memilikinya. Contoh klasiknya adalah Pimpl Idiom (see GotW #100):

// C++11 Pimpl idiom: header file
class widget {
public:
    widget();
    // ... (see GotW #100) ...
private:
    class impl;
    unique_ptr<impl> pimpl;
};

// implementation file
class widget::impl { /*...*/ };

widget::widget() : pimpl{ new impl{ /*...*/ } } { }
// ...

Gunakan shared_ptr untuk mengekspresikan kepemilikian bersama. Gunakan make_shared untuk menciptakan object yang di share tersebut dengan efisien.

// C++98
widget* pw = new widget();
:::
delete pw;

// C++11
auto pw = make_shared<widget>();

Gunakan weak_ptr untuk menghindari cycle dan mengekspresikan optionality (implementasi cache object)

// C++11
class gadget;

class widget {
private:
    shared_ptr<gadget> g; // if shared ownership
};

class gadget {
private:
    weak_ptr<widget> w;
};

Jika anda mengetahui bahwa object tersebut akan meninggalkan anda dan anda ingin mengamatinya, gunakan non-owning raw pointer.

// C++11
class node {
 vector<unique_ptr<node>> children;
 node* parent;
public:
 :::
};

Range for

Perulangan for each lebih nyaman digunakan untuk melakukan iterasi dari setiap elemen pada koleksi secara berurutan.

// C++98
for( vector<int>::iterator i = v.begin(); i != v.end(); ++i ) {
    total += *i;
}

// C++11
for( auto d : v ) {
    total += d;
}

Non member begin dan end

Selalu gunakan nonmember begin(x) dan end(ex) (bukan x.begin() dan x.end()), karena begin(x) dan end(x) lebih ekstensible dan dapat digunakan dengan berbagai jenis tipe container bahkan array dan tidak hanya STL container yang menyediakan method x.begin() dan x.end()

Jika anda menggunakan collection non-STL yang menyediakan iterasi tetapi tidak memiliki x.begin() and x.end() anda dapat menuliskan versi overloading dari non-member begin(x) dan end(x) utuk tipe tersebut dimana anda dapat menjalani tipe koleksi tersebut dengan menggunakan gaya pemrograman yang sama dengan container STL. Standar memiliki beberapa contoh dari penggunaan untuk array C

vector<int> v;
int a[100];

// C++98
sort( v.begin(), v.end() );
sort( &a[0], &a[0] + sizeof(a)/sizeof(a[0]) );

// C++11
sort( begin(v), end(v) );
sort( begin(a), end(a) );

Fungsi Lambda dan Algoritma

Lambda merupakan perubahan yang sangat besar dan akan mengubah cara anda menulis kode menjadi lebih elegan dan cepat. Lambda membuat algoritma STL yang sudah ada menjadi lebih berguna 100 x lipat. Library c++ yang baru dirancang dengan mengunakan lambda (contoh: PPL (parallel pattern library)) dan beberapa diantaranya mewajibkan anda menggunakan lambda untuk menggunakan library tersebut (C++ AMP)

Berikut contoh singkatnya : Temukan elemen pertam di v dimana >x dan <y. Pada c++11, code yang paling simple dan bersih adalah dengan menggunakan algoritma standar yang tersedia

// C++98: write a naked loop (using std::find_if is impractically difficult)
vector<int>::iterator i = v.begin(); // because we need to use i later
for( ; i != v.end(); ++i ) {
    if( *i > x && *i < y ) break;
}

// C++11: use std::find_if
auto i = find_if( begin(v), end(v), [=](int i) { return i > x && i < y; } );

Jika anda ingin perulangan atau fitur bahasa yang serupa tetapi tidak tersedia. Tidak masalah. Anda dapat menuliskannya sebagai fungsi template (library algorithm) dan terima kasih kepada lambda anda bisa menggunakannya seolah olah hal tersebut fitur bahasa c++, dan lebih flexible karena merupakan library dan bukan merupakan fitur bahasa.

// C#
lock( mut_x ) {
    ... use x ...
}

// C++11 without lambdas: already nice, and more flexible (e.g., can use timeouts, other options)
{
    lock_guard<mutex> hold { mut_x };
    ... use x ...
}

// C++11 with lambdas, and a helper algorithm: C# syntax in C++
// Algorithm: template<typename T> void lock( T& t, F f ) { lock_guard hold(t); f(); }
lock( mut_x, [&]{
    ... use x ...
});

Biasakan menggunakan lambda. Anda akan banyak menggunakannya, dan tidak hanya di c++, tetapi banyak bahasa popular lain yang sudah mengadopsinya. Anda dapat memulai belajar mengenai lambda dengan menonton presentasi Lambdas, Lambdas Everywhere at PDC 2010

Move / &&

Move dapat dianggap sebagai optimisasi dari copy, meskipun dapat digunakan juga untuk perfect forwarding

Move mengubah cara kita merancang API kita. Kita akan lebih sering melakukan return by value dibandingkan sebelumnya.

// C++98: alternatives to avoid copying
vector<int>* make_big_vector(); // option 1: return by pointer: no copy, but don't forget to delete
:::
vector<int>* result = make_big_vector();

void  make_big_vector( vector<int>& out ); // option 2: pass out by reference: no copy, but caller needs a named object
:::
vector<int> result;
make_big_vector( result );

// C++11: move
vector<int> make_big_vector(); // usually sufficient for 'callee-allocated out' situations
:::
auto result = make_big_vector(); // guaranteed not to copy the vector

Tambahkan move untuk tipe anda jika anda ingin melakukan sesuatu yang efisien dibandingkan copy.

Uniform Initialization and Initializer Lists

Hal yang tidak berubah adalah ketika kita melakukan inisialisasi terhadap variable local yang memiliki tipe Plain Old Data atau auto, kita akan tetap menggunakan = tanpa extra {}.

// C++98 or C++11
int a = 42;        // still fine, as always

// C++ 11
auto x = begin(v); // no narrowing or non-initialization is possible

Untuk kasus lain, anda akan menggantikan () untuk membuat object, dengan menggunakan {}. Menggunakan {} menghindarkan beberapa masalah, yaitu anda tidak akan mendapatkan konversi otomatis (float ke int) secara tidak disengaja, dan anda tidak akan mendapatkan variable atau array POD yang tidak terinisialisasi, dan anda akan menghindarkan kesalahan bahwa code anda dapat di compile tetapi yang mendeklarasikan fungsi dan bukan variable karena ambigu pada grammar c++( Scott Meyers menyebutnya sebagai “c++’s most vexing parse”. Tidak ada yang menjengkelkan dengan gaya yang baru ini.

// C++98
rectangle       w( origin(), extents() );   // oops, declares a function, if origin and extents are types
complex<double> c( 2.71828, 3.14159 );
int             a[] = { 1, 2, 3, 4 };
vector<int>     v;
for( int i = 1; i <= 4; ++i ) v.push_back(i);

// C++11
rectangle       w   { origin(), extents() };
complex<double> c   { 2.71828, 3.14159 };
int             a[] { 1, 2, 3, 4 };
vector<int>     v   { 1, 2, 3, 4 };

Sintaks {} dapat digunakan hampir dimana saja

// C++98
X::X( /*...*/ ) : mem1(init1), mem2(init2, init3) { /*...*/ }

// C++11
X::X( /*...*/ ) : mem1{init1}, mem2{init2, init3} { /*...*/ }

Kadang-kadang lebih menyenangkan untuk melewatkan argument dari fungsi tanpa membuat tipe sementara.

void draw_rect( rectangle );

// C++98
draw_rect( rectangle( myobj.origin, selection.extents ) );

// C++11
draw_rect( { myobj.origin, selection.extents } );

Satu-satunya tempat dimana {} tidak digunakan adalah untuk inisialisasi sederhana dari variable non-POD seperti auto x = begin(v);,
Dimana code akan menjadi lebih jelek jika kita melakukannya, karena kita tahu bahwa tidak perlu pusing dengan konversi, dan compiler modern akan melakukan optimisasi untuk mencegah extra copy (atau extra move jika type merupakan move-enabled)

Dan banyak lagi

Masih banyak lagi fitur yang belum dijelaskan. Much more. Dimasa depan saya akan menuliskan lebih detail mengenai fitur-fitur berikut dan fitur lain yang akan kita ketahui dan cintai
Tetapi untuk sekarang ini, ini adalah kumpulan dari fitur-fitur yang wajib kita ketahui. Fitur ini merupakan inti yang mendefinisikan gaya pemrogramam c++ yang baru, dimana kode c++menjadi lebih elegan dan akan digunakan dibanyak tempat. Fitur tersebut juga akan membuat modern c++ menjadi bahasa pemrogrman bersih, aman, dan cepat, tetap digunakan industry pada tahun-tahun mendatang.

Categories: c++, C++11, Visual C++ Tags: , ,

C++ Major Books

March 4, 2012 Leave a comment

Banyak sekali buku yang beredar mengenai c++. Kita tentu saja tidak dapat membacanya semua. Beberapa buku berikut merupakan buku yang direkomendasikan oleh Herb Sutter untuk dibaca melalui GoingNative 2012.

  1. C++ Primer ( moo, stanley lippman )
  2. The C++ Programming Language (stroustrup)
  3. Programming : Principle & Practice using C++ (stroustrup)
  4. Effective c++ (meyers)
  5. C++ Coding Standards (sutter, alexandrescu)

Beberapa buku di atas akan release tahun ini. Tentu saja isi dari buku tersebut akan mencakup penambahan yang ada di c++11. Sedangkan beberapa buku lain masih harus kita tunggu bersama-sama karena tentu saja para penulis butuh belajar juga mengenai c++11.

Saran saya adalah untuk buku yang belum terbit silahkan baca buku versi sebelum, dan kemudian kita analisa apakah konsep yang diajarkan dalam buku tersebut masih relevant atau tidak untuk Modern C++.

Let’s Get Started from Now.

 

 

Categories: c++, C++11 Tags: , ,

Going Native untuk C# dan .NET Developer

February 29, 2012 Leave a comment

Beberapa bulan belakangan ini Microsoft dengan gencar menggalakkan program Going Native atau sering juga disebut sebut C++ Renaissance. Hal ini tentu menarik perhatian banyak programmer managed code (c# .net). Ada mungkin yang merasa terusik dengan kebangkitan kembali c++, ada juga yang skeptic dsb.

Sebelum memberikan banyak komentar mengenai Going Native ini, mungkin terlebih dahulu kita harus terlebih dahulu mengakui bahwa software di dunia ini paling banyak ditulis dengan c. Sebut saja operating system linux dan windows. Sehingga bagaimanapun kita tidak akan lepas dari native code.

Dunia Windows

Saya bekerja di lingkungan Windows, wajar saja karena saya adalah .NET developer. Sistem operasi Windows tentu saja tidak dapat dipungkiri yang paling banyak penggunanya. So we have to face it. We’re living in Windows World.

Code base dari Windows sendiri banyak ditulis dengan menggunakan C. Seiring dengan berjalannya waktu maka code c tersebut dibungkus dengan menggunakan C++ sehingga terlihat Object Oriented. – -“

Tetapi tetap saja native dari C tidak hilang.

Untuk sejenak kita tinggalkan dunia .Net dan kilas balik ke dunia sebelumnya dimana Win32 adalah segalanya. Anda akan berkenalan dengan MFC, COM dan ATL. Kesemuanya itu familiar untuk kalangan Win32 programmer.

.NET dan keterbatasannya

Sejak kemunculan .NET framework maka banyak orang beranggapan bahwa C++ sudah tidak relevan lagi di dunia industry. Hal ini bisa jadi benar tergantung di lingkungan mana orang tersebut berada. Jika kesehariannya pekerjaannya adalah membuat business application yang berkutat dengan data,data dan data binding ? Maka tidak ada gunanya untuk menggunakan c++ untuk hal tersebut, karena salah satu inti dari software development adalah produktifitas dari programmer.

Tetapi…. Kadang kala kita akan berhubungan dengan kasus dimana .NET mencapai keterbatasannya. Tidak semua Win32 API di ekspose ke managed c#. Kadang kala kita harus membuat wrapper untuk mengakses Win32 API tersebut.

Meskipun Microsoft sudah menyediakan alternative untuk menutupi kekurangan managed code tersebut dengan menyediakan Windows API Code Pack. Tetap library tersebut tidak mencakup keseluruhan dari Win32 API. Kita juga tidak dapat mengharapkan Microsoft untuk menulis ulang dari library tersebut sepenuhnya ke c#. Coba lihat Visual Studio 2010. Visual Studio 2010 memanfaatkan ketangguhan dari WPF and XAML. Tetapi tetap saja code native sebelumnya tidak bakalan dibuang begitu saja. Native code still exist. That’s the point. Library tersebut pasti di reuse dan di wrap sehingga dapat diakses dari .NET.

http://archive.msdn.microsoft.com/WindowsAPICodePack

http://windowsteamblog.com/windows/b/developers/archive/2009/05/18/windows-7-managed-code-apis.aspx

http://windowsteamblog.com/windows/b/developers/archive/2010/04/27/windows-api-code-pack-past-present-and-future.aspx

http://www.microsoftpdc.com/2009/CL12

Suatu saat mungkin anda akan merasakan hal yang sama ketika dihadapkan kepada kasus dimana .NET tidak dapat menyelesaikan masalah anda sepenuhnya. Saya juga pernah mengalaminya ketika mengerjakan tugas kantor yang berhubungan dengan Video dan Audio processing. Pada akhirnya tetap saja kita harus mengakses dan menggunakan library Win32, COM dengan menggunakan interoperability.

Interoperability juga harus dilakukan dengan hati2 karena kita bisa kena performance penalty jika melakukannya sembarangan.

Beberapa website ini akan memberikan anda gambaran dan pembuktian mengenai keterbatasan .NET dalam beberapa hal sehingga membutuhkan c++.

http://www.streamcoders.com/

http://wpfmediakit.codeplex.com/

http://jeremiahmorrill.com/

Ada beberapa cara untuk melakukan interop .NET ke C++. Saya hanya akan memberikan pointer kepada anda untuk melakukan eksplorasi sendiri.

http://blogs.microsoft.co.il/blogs/sasha/archive/2008/02/16/net-to-c-bridge.aspx

http://msdn.microsoft.com/en-us/library/aa730837(v=vs.80).aspx

http://stackoverflow.com/questions/1933210/c-cli-why-should-i-use-it

Apakah anda sudah dapat menerima mengapa managed guy juga membutuhkan native code ?

Tentu saja saya akan melanjutkan inception ini 🙂

Dari penjelasan di atas saya akan memberikan beberapa point dimana kita membutuhkan native c++. Seperti yang kita ketahui bahwa c++ merupakan bahasa yang dekat ke mesin, memiliki abstraksi yang bagus tanpa mengorbankan performance. Sehingga c++ sangat bagus untuk hal-hal berikut

  1. Mengakses Operating System resource,
  2. Hardware
  3. Graphical processing
  4. Computing power
  5. Game programming dengan DirectX
  6. Mengunakan code yang sudah ada dan ditulis dengan menggunakan c, c++

Saya tidak mengatakan bahwa kita harus sepenuhnya pindah agama ke c++. Saya hanya mengingatkan  bahwa kita sebaiknya mempersiapkan diri jika dihadapkan dengan keterbatasan managed code. Saya berharap agar kita dapat mengantisipasi hal ini.

C++11

C++ sendiri sudah mengalami perubahan yang sangat besar belakangan ini. C++11 yang baru saja disahkan akhir tahun lalu benar-benar berbeda dengan c++ yang dulu anda kenal. Seperti yang dikatakan oleh pembuatnya Bjarne Stroustrup, c++11 feels like a new language. Jika anda merupakan programmer c++ veteran maka anda dapat mengupgrade pengetahuan anda mengenai perkembangan yang ada. Jika anda merupakan pendatang baru maka anda dapat saja langsung belajar style baru dengan c++11.

Learning something new wouldn’t hurt right ?

Windows 8

Dengan datangnya Windows 8 dengan MetroStyle UI yang diprediksi bakalan release tahun ini, semakin membuat dunia Windows bervariasi. JavaScript dan HTML developer sekarang sudah menjadi first class language untuk melakukan pembangunan aplikasi MetroStyle. Apakah ini membuat c# dan c++ menjadi tidak relevant lagi ?

Tentu saja tidak.

Masing-masing developer dapat memilih alat yang dirasa sesuai dan nyaman digunakan. Tapi…

Satu hal yang pasti adalah keterbatasan di JavaScript, C# tetap masih ada di MetroStyle Apps. Sama saja seperti kasus di Windows sebelumnya. Kedatangan WinRT mungkin membawa angin segar bagi Windows Developer yang tidak familiar dengan COM dan kerumitannya. Tetapi tetap saja untuk saat ini tidak semua Win32 yang dibungkus oleh WinRT.Sebagian harus diakses langsung dengan menggunakan Win32 atau kita harus membuat WinRT component dan mengaksesnya dari JavaScript atau C#.
Tidak jauh berbeda bukan dari jaman ke jaman.

C++ selalu menghantui hidup kita. Kita mungkin bisa lari dan mengabaikan tetapi suatu saat kita pasti dihadapkan kepada keterbatasan itu. One language that can do it all is c++.

Berikut salah satu video yang saya rasa menggambarkan pentingnya interoperability ke c++

http://channel9.msdn.com/posts/Raman-Sharma-Building-Metro-Style-Apps-with-C-and-JavaScript

Anda ingin membuat games dengan DirectX di MetroStyle?

Yeah. That’s should be in c++ I think. There’s no other choice.

Parallelism

Salah satu hal yang makin marak belakangan ini juga adalah mengenai parallelism. C# 5 juga sangat gencar dengan fitur ini.

Nah bagaimana dengan c++ ?

Pagi ini saya baru saja menonton video yang mungkin membuat anda semakin yakin bahwa c++ pantas untuk dipelajari. J. Video ini mengenai c++ AMP (

http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-802T

Video tersebut mengenai C++ AMP (Accelerated Massive Parallism)

Nama yang cukup menakutkan bukan ?

Saya langsung saja mencari padanan dari hal tersebut di c#. Kemudian saya pulang dengan tangan hampa. L. Kita harus melakukan interoperability lagi untuk hal ini.

http://blogs.msdn.com/b/pfxteam/archive/2011/09/21/10214538.aspx
http://blogs.msdn.com/b/pfxteam/archive/2011/11/12/10236375.aspx

C++ untuk c# developers ?

Jadi tidak aneh saya rasa jika dengan kemunculan Windows 8 dan MetroStyle appsnya, c++ semakin relevan di industry. Saatnya bagi kita programmer c# untuk belajar c++. Ingat bahwa ini adalah investasi. Kita tidak akan merasakan efeknya sekarang tetapi di masa yang mendatang. J. Berikut adalah buku yang membantu anda untuk melakukan pengenalan dengan c++

http://blogs.msdn.com/b/jerrynixon/archive/2012/02/20/c-for-c-developers.aspx

Persiapkan diri anda untuk menyambut Windows 8 dengan c++. :).

Go Native!!