Tuesday, December 24, 2013

Season’s surprise: IE 11 for Windows 7 SP1 and Windows Server 2008 R2 SP1 is released

Yes! Previously available for Windows 8.1, now IE 11 is also available for Windows 7 SP1 and Windows Server 2008 R2 SP1.

I recommend you, my blog audience, to download the 64bit version as Microsoft is moving towards 64bit.

In fact, Windows Server 2012 R2 is only available in 64 bit!

This is the download page URI: http://windows.microsoft.com/en-us/internet-explorer/download-ie

Microsoft is also beginning to broadcast IE 11 downloads:


Enjoy full speed browsing in IE 11!

Thursday, December 19, 2013

RX Web Services journal: WCF in .NET 4.0 implicitly fits REST Maturity Model Level 2

Hi my blog readers!

Another journal is born! now RX journal about web services!

I have just dived deep in .NET 4.0 technology stack, when this week I was assigned to create web services. As .NET mostly guy, I revisit my skill in creating WCF.

Outside world, many things happened. The need of having REST services with the correct model and incorporating HTTP verbs (not just GET and POST) is becoming crucial and more relevant.

Fortunately, Leonard Richardson has written the REST maturity model as the baseline for us. But Martin Fowler, the best known guy that one popularized DSL and PoEAA (Patterns of Enterprise Application Architecture) helped us to understand REST maturity model.

Martin Fowler described the levels into these:

  • Level 0 – RAW HTTP
  • Level 1 – Resources (with HTTP binding as endpoints)
  • Level 2 – HTTP verbs
  • Level 3 – Hypermedia

Level 0 means you’re using RAW HTTP with either GET or POST, but the resulting request and response is plain XML. This is why Martin describes this Level as swamp of POX (Plain Old XML). A good sample of this is .NET Remoting using RPC in .NET 2.0 and above and Java’s RMI. In Level 0, the talks only involves talking to only one endpoint.


Level 1 means you’re considering the request and response as real HTTP object, but the main concern here is talking and requesting specific resources as part of HTTP conversation.

This picture was taken from Martin Fowler’s article:


This means not just specifying endpoint, but we also specify which resources needs to be sent and to have.

Level 2 means incorporating HTTP verbs, meaning that now not only specific resources, but it’s also introducing HTTP verbs with response codes.


This means that Level 2 add more concern on separation of which HTTP verbs are changing states and not changing states.

These HTTP verbs change states:

  • POST
  • PUT

This HTTP verb does not change state:

  • GET

Fortunately, WCF in .NET 4.0 is confirmed to have full support of Level 1 and with more care, it also supports Level 2.

This is a small sample of Level 1: (an operation contract of testvalue)


And this is the explanation related to the REST levels:


It’s quite simple in WCF, isn’t it? But when you consider Level 2, you also have to pay attention to the verb and the HTTP returning status codes.

Supports for setting and getting HTTP status code is available in WCF using WebOperationContext.

I’ll dive into WCF supports for Level 2 in the next blog entry about this.

Put it simply, Level 2 concerns about:

  • Resource specific (as in Level 1)
  • using HTTP verbs
  • specifying HTTP status codes (for each HTTP verb used) as a mean to define what is the nature of the resulting resource.

Level 3 add concerns about using HTTP as the transport for Hyper media, means that the data will have the additional information of what is the next destination.

It’s quite elegantly illustrated as below picture:


As you can see, there’s additional information in the forms of links to the resource. This means that the hyperlinks in the data has to be specified.

Further references

Tuesday, December 10, 2013

TEACHING: Study club of MUGI Jadetabek on Developer Track, WEEK 4

Now, it’s week 4! We could not have the workshop within the next week of week 3 because of my busy schedule, sorry!

Also in the week 4, we decided to meet at QQ Kopitiam, at Pacific Place at 9:30 because I had something to do first in the morning. Not just my schedule, but the study club will need to adjust with the participants. Therefore this week 4 was commenced on 7th December, 2013.

To my surprise, the attendance were few: Wakhid and Aris weren’t present. But Wakhid was able to tell me that he’s still minding his final paper assignment.

Ok, the show must go! Sorry to leave you if you weren’t present, guys!

This week I reviewed the knowledge of basic generic and collection. To my surprise, not all of them understood and grabbed the full concept of last week.


The assignment was to create a simple implementation of LINQ’s WHERE and also implement ICollection<T>, so I decided to repeat the explanation on how generic works.

Basically we can consider generic type as parameterized type or type as parameter. So, if we declare ICollection<T>, we could use and implement derived ICollection with String as parameter (or any type).

The type T then can be replaced by String, so the use will be ICollection<String> (read as ICollection of String). In fact, arrays in .NET 2.0 and above are implemented as collections of parameterized type, so when we have array of bytes, it’s actually implemented as collections of strongly typed bytes, not just array of boxed objects.

Sample from MSDN: (from http://msdn.microsoft.com/en-us/library/vstudio/b5bx6xee%28v=vs.110%29.aspx)

// The .NET Framework 1.1 way to create a list:
System.Collections.ArrayList list1 = new System.Collections.ArrayList();

System.Collections.ArrayList list2 = new System.Collections.ArrayList();
list2.Add("It is raining in Redmond.");
list2.Add("It is snowing in the mountains.");

Although it’s very subtle, the ArrayList will cast to objects, and this is called boxing.

As consequences, we also need to understand boxing and unboxing concept in C# and VB. For more info, visit boxing and unboxing in MSDN Library.

Now with .NET 2.0 and above, we can create list with strong typed:

// The .NET Framework 2.0 way to create a list
List<int> list1 = new List<int>();

// No boxing, no casting:

// Compile-time error:  // list1.Add("It is raining in Redmond.");

Now every time we access each or any member of list1, we are confident that the type of the member is int.

This type parameter concept is very powerful, and it’s becoming a basic feature for all modern programming language nowadays. Not just languages on top of .NET platform, .NET itself has integrate generic deeply as part of CLI and CLR implementation.

Other platform such as Java had begun implementation of generic in Java 5 (JDK 1.5.0) although it came late. Luckily, there’s an official tutorial of generics in Java from Oracle.

By integrating generic deeply into the runtime, now it’s up to the programming language to leverage this! In .NET, we have C#, VB, F#, C++.

Hey, it’s time for the participants to try!


Finally, they could create the LINQ WHERE! …And now time to eat!


Next meetup: advanced LINQ concept.


Again, I encourage all of you to read TAPL book by Benjamin Pearce, to fully understand the type theory behind generic type.

Thursday, November 28, 2013

Team Foundation Service is now called Visual Studio Online

Hi my blog audiences!

My favorite free Team Foundation Service is now called Visual Studio Online!

This is the original official announcement: http://www.visualstudio.com/en-us/news/2013-nov-13-vso


It’s also coincidence with the launch of Visual Studio 2013!

Also we can code using Visual Studio by online using “Monaco” (Microsoft codename):


Monaco will support ASP.NET, Javascript, Ruby, Python and PHP!

Now the pricing for Visual Studio Online is complete:


The good news is for 5 developer in a team (or less) the price is free. For more than 5 developers, Visual Studio Online is available in subscription levels.

The level is Basic, Professional and Advanced, and here’s the official comparison table:


Now, what are you waiting for? Start code today in a team!

Monday, November 18, 2013

TEACHING: Study club of MUGI Jadetabek on Developer Track, WEEK 3

It’s week 3 now! Time for MUGI participation! Now MUGI Jadetabek has initiated study club. Initially we have two tracks: developer track and infrastructure track.

Initially started as an idea from Abdullah Muhammad (chairman of MUGI Jadetabek) and I when attending Microsoft Community Summit, now it becomes realization. The place is at Microsoft Indonesia’s main office, JSX on 18th floor.

The course will be in the form of 5 times informal meeting weekly.

For developer track, we have 5 attendees. We have decided to limit the number of attendees for now, as we want to spread and teach the knowledge effectively.

Initial developer track will be delivered by myself, Eriawan. As for now, I deliver introduction to C#.

Week 3 is on 8th November, still at the same Microsoft Indonesia’s HQ at BEJ Jakarta.

Now, the subject is about advanced OOP and collections in .NET (including generics).

This week we only have 2 attendances because Wakhid was taking care of his final paper assignment and Aris was sick.

I had demo on LINQ Select:


As always, the show must go on!


We moved to smaller rooms but I think it’s good, because it separated from the Infrastructure track that begins on developer’s week 3!

I gave home assignments to create implementations of ICollection<T> and also create WHERE method of LINQ.

As promised, the slide deck will be uploaded soon. I hope tomorrow I can download the slide gracefully as it’s quite large, more than 6MB!

The next week 4 will be scheduled on 23rd November. Stay tuned!

Friday, November 8, 2013

TEACHING: Study club of MUGI Jadetabek on Developer Track, WEEK 2

For developer track, we have 5 attendees. We have decided to limit the number of attendees for now, as we want to spread and teach the knowledge effectively.

Initial developer track will be delivered by myself, Eriawan. As for now, I deliver introduction to C#.

Hi there! This is Week 2 of Developer track study club, part of MUGI Jadetabek community program. As usual, we held this on Microsoft Indonesia office, on 2nd November, 2013.

This week I bring OOP concept in C# and the OOP.

Official link for OOP in C# and VB (for Visual Studio 2012) is at: http://msdn.microsoft.com/en-us/library/dd460654%28v=vs.110%29.aspx

Before that, we spent 1 hour to discuss last week homework task: creating butterfly.

These are the pictures from Week 2:


And this is another style pose: Smile


Basically, OOP has these 3 pillars:

  1. Inheritance
  2. Polymorphism
  3. Encapsulation

Unfortunately, OOP was not described well in MSDN Library.

I suggest we look at the Oracle’s Java documentation of OOP at: http://docs.oracle.com/javase/tutorial/java/concepts/

They have nice illustration to describe encapsulation:


And the sample in real world:


The slide will be available on week 3, tomorrow!

Friday, November 1, 2013

RX Communica SDLC Journal: Feature Points

Hello there! I’m now writing about SDLC in the form of journal.

The journal will contain my quick insight and ideas taken from best practices, and it also contains my company’s (RX Communica) shared perspective and practices. RX Communica is my own hybrid of non-profit and profit company.

This journal doesn’t have to be in order of learning sequence, not like my F# adventure series. Enjoy!

Now I’ll discuss feature point!

Feature point is a weighted score, and it should be based on how much the feature is anticipated based on "MUST HAVE" of Moscow method. It can also have psychological cost, in a sense of the importance of the feature.

At first creation, a feature will have either zero or positive point, but as the feature is used, it can also have negative point.

User feedback, especially when it's focused on a feature will be counted as a weighted score point.

These are the sample use cases and reasonings:

  • If there's many negative point for this feature and if this feature is the base foundation for all other feature, then this feature needs to be prioritized to have attention, but it doesn't have to be integrated first. The attention is very critical, that it may lead to feature detach (abandon) or recreate the feature with different logic and refined functional spec and technical requirements. In my previous experience, the integration of this feature can be deferred for next minor or major release, depends on the criticalness.
  • The feature that has many negative points should be considered as technical debt that has to be paid soon, as a debt has to be paid in order to decrease critical back log of feature defect that wasn't good thought at the beginning.
  • If there's a new feature as the evolution consequence from this feature, then the new feature request based on this one should be rejected or we can investigate further and communicate to the stakeholder that this feature is based on current feature's negative points and it will add more negative points.
    This can lead to further democratization of how we provide the servicing of feedbacks from stakeholder, as if the positive feedbacks don't outweight the negative feedback, we can safely weighing more and leaning more on positive feedback as the source of prioritization consideration. This technique often called "crowdsourcing" but only in scope for software development.
  • If the feature has many positive points and also has positive feedback points, then this feature can accept future enhancements.
  • The feature (or can be features) that meets our coding and high reliability standard on extensibility (including the notion of Open-Closed principle from SOLID principle) has to be integrated first because it's easier to integrate with high confidence. This feature is therefore have high positive feature points.
  • By keeping these green field and feature point concept from start, we will not be trapped easily into brown field model and complexity (smile)

This is to illustrate the fate of a feature in feature points perspective:


If you read the Code Complete 2nd Edition book, the feature point can be used to prioritize integration between features. Feature dependencies should be taken into account first, provided that you have dependency documentation available clearly. If there’s no documentation, then there’s a large possibility that the the software project will fail in the middle of development, test, or even when used in live production.

There’s a video from Channel 9 MSDN website that quickly describe feature point in action. This video is about the introduction to C# 4 design team, but it’s very worthy to watch.

Here’s the link: http://channel9.msdn.com/Blogs/Charles/C-40-Meet-the-Design-Team

NOTE: the feature points not to be confused with feature point matrix of function points.

Further references

  1. Code Complete 2nd Edition for online reading (if you have Safari account): http://techbus.safaribooksonline.com/book/software-engineering-and-development/0735619670
  2. Code Complete 2nd Edition book to buy at Amazon: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/
  3. Function points for measuring algorithm, inputs, outputs complexities: http://www.spr.com/feature-points.html
  4. MosCow method: http://en.wikipedia.org/wiki/MoSCoW_Method
  5. Crowdsourcing: http://en.wikipedia.org/wiki/Crowdsourcing

Tuesday, October 29, 2013

TEACHING: Study club of MUGI Jadetabek on Developer Track, WEEK 1

Time for MUGI participation! Now MUGI Jadetabek has initiated study club. Initially we have two tracks: developer track and infrastructure track.

Initially started as an idea from Abdullah Muhammad (chairman of MUGI Jadetabek) and I when attending Microsoft Community Summit, now it becomes realization. The place is at Microsoft Indonesia’s main office, JSX on 18th floor.

The course will be in the form of 5 times informal meeting weekly.

For developer track, we have 5 attendees. We have decided to limit the number of attendees for now, as we want to spread and teach the knowledge effectively.

Initial developer track will be delivered by myself, Eriawan. As for now, I deliver introduction to C#.

This is the picture from Week 1 on 26th October, 2013:


Above, Abdullah was delivering welcome speech.

I start this week with these discussions:

  1. Quick intro to Visual Studio 2012
  2. Installing offline documentation of Visual Studio 2012
  3. Creating Visual Studio C# project
  4. Basic primitive type of C#
  5. Looping (for and foreach)

The topics above was adjusted with the current knowledge and current understanding of the audiences. This is why some of the topics are very basic.

In this week, I gave them homework task to display butterfly using “*” and spaces.

The slides will be ready after week 3, based on the evaluation for 2 weeks of participation, guys!

The next week: Fundamentals of OOP!

Interested? Ask Abdullah Muhammad, or visit MUGI Jadetabek on Facebook!

Thursday, October 24, 2013

Visual Studio 2013 has been released

Hi my blog audiences!

Yes, you’re right! It’s not a typo! Visual Studio 2013 has been released and available to download!

Just go to: http://www.microsoft.com/visualstudio/eng/products/2013-editions

This is the original announcement by Somasegar in his blog: http://blogs.msdn.com/b/somasegar/archive/2013/10/17/visual-studio-2013-available-for-download.aspx

What’s new in Visual Studio 2013: http://www.microsoft.com/visualstudio/eng/visual-studio-2013

The editions of Visual Studio 2013 are the same as Visual Studio 2012:

  1. Express
  2. Test Professional
  3. Professional
  4. Premium
  5. Ultimate

For those new to Visual Studio, I suggest starts using Visual Studio 2013 Express Edition.

Here’s the link: http://www.microsoft.com/visualstudio/eng/downloads#d-2013-express


Now, everything is getting more interesting in Visual Studio world! Visual Studio will have shorter cadence release! This is also a perfect sample of Application Lifecycle Management discipline clearly implemented!


The picture was from a slide deck of Brian Harry, MS Technical Fellow, when delivering presentation on TechEd North America 2013.

This means, every 11 to 13 months a new Visual Studio version will always be available.

Friday, September 27, 2013

Implementations of Memoization in F#

Today let’s talk about memoization.

This is the definition of memoization in Wikipedia:

“memoization is an optimization technique used primarily to speed up computer programs by having function calls avoid repeating the calculation of results for previously processed inputs.”

To put it simple, memoization is a technique by remembering the previous result of the function results. This implies that memoization is best to use as recursive functions, because it needs to call itself again!

The need to store values means that it needs mechanism to store result value.

To implement this mechanism, of course we need another helper variable to store the result.

Don Syme, the original creator of F# has this simple sample of memoization on his blog.

Here’s his starting sample:


There’s no further explanation about how the code above works. We’ll try to dive it together.

In his first sample, type checking on x (as x in the “fun x –>”) will always be performed.

He used System.Collections.Generic.Dictionary of <_,_> to map x as the key and fill the value with the result of computation of f x.

This is the power of type inference in action, so we can expressively map Dictionary<_,_> to have two kinds of generic type without naming it.

F# then will infer the first “_” as the key, and the second “_” as the type of the value.

The signature of “memoize f” is “('a -> 'b) -> ('a -> 'b)”.

The Dictionary used then will be used as a cache to store result value.

He further update the memoization sample.

This is the update using unchecked type:


And now using single mutable reference of Map:


The code above is more functional because it uses immutable F# Map instead of mutable System.Collections.Generic.Dictionary and also easier to understand, though using Unchecked is cleaner in some sense of C# perspective.

Tuesday, September 10, 2013

Another reasons to use F#: Why use F#

Wow! I really missed this gem!

There is a website dedicated for explaining why using F# is fun and also profitable.

The link is: http://fsharpforfunandprofit.com/why-use-fsharp/ and it’s very informational!

There you can find a series of 30 parts of defining “Why use F#” in a very short but concise.

The main reasons of Why use F# are:

  • Conciseness
  • Convenience
  • Correctness
  • Concurrency
  • Completeness

The nice additional feature is, they have syntax highlight!


Definitely one of the best F# resource to keep! Smile

Tuesday, August 20, 2013

KASKUS Programmer forum gathering on 18th August 2013

Hi all!

Now I got invited by Kaskus programmer forum participants to meet at gathering session at FX Plaza on 18th August, 2013. In this gathering, there were more audiences than previous gathering.

For those wondering what Kaskus is, Kaskus is simply a free social gathering of those that has the same interest. It is generally more relaxed as there’s no organizational chapter whatsoever. It has governed by nobody but the forum is strictly moderated.

My main focus at Kaskus is the Programmer forum, and we usually have gathering for every 6 months.

I got the chance to demo what is lazy evaluation in C#/VB and the proof of the magic behind it.

Lazy evaluation in form of yield iterator in C# and VB (although VB has it since Visual Studio 2012). Using yield will make the code that use the iterator will be executed later, rather than immediately. This can be regarded as on demand but yield has more machinery. It can be seen as having a state machine to keep the state that it will run only as needed, especially when it comes to iterate an IEnumerable.

This is the code in Visual Studio 2010:


Just put the breakpoint at the line in the foreach in the Main method and run it.


At first breakpoint, the code Select above it is not yet executed. After going stepping to “in” before procnames, then the Select method above will be executed.

You, my dear reader, might wonder what select is. Select comes interpreted from an extension method of Select (look at this keyword).


The code above is basically also a demo of how we can implement our own Select as select in LINQ to object. In fact, I have no reference on System.Linq at all!

By the way, the untranslated code of calling Select is:


Now I can argue that using LINQ is better, isn’t it?

Not just .NET, we were also having discussion on Java, PHP, and many things about programming as well.

Who are those attending this gathering?

Before that, here’s the picture of all attendances:


For more information on all of the gathering, please visit this thread on KASKUS forum programmers: http://www.kaskus.co.id/thread/51fb2a208327cfde1400000a/kopdar-programmer/

Thanks to Felix (cpuclear2) and Habib (bluething) for the pictures!

Monday, July 15, 2013

Current state and product lifecycle of Visual Studio in July 2013

Hi, .NET developers!

In Microsoft terms, the no longer supported means the product has gone passing through mainstream support period. The Extended support period means that there's additional charge for additional support beyond mainstream support.

We shall put our focus on at least Visual Studio 2010 Professional or Ultimate, because Visual Studio 2008 has passed its mainstream support phase.

Visual Studio 2012 has Update 3 (consider it as "Service Pack 3" cumulative update).

Visual Studio 2013 is going to be released soon, the date is October 18 2013, the same date of the worldwide launch of Windows 8.1.

Visual Studio 2005 is no longer supported, although extended support is still available until 2016. Visual Studio 2008 is coupled with .NET 3.5 release, and both of these product has the same mainstream support end date.

For Visual Studio 2005 period is below:



Visual Studio 2005 SP1 has brought some life to Visual Studio 2005, but the support for SP1 is given after one year of mainstream support: (although Microsoft only said "end of product's support lifecycle")



Visual Studio 2008 Standard and Professional edition support:



Again, based on the table above, Visual Studio 2008 SP1 will extend the support slightly longer, but only one year after the release of the service pack.

What about Visual Studio 2010? Visual Studio 2010 still has the mainstream support:



We can still count on Visual Studio 2010 until July 2015.

The latest release, Visual Studio 2012, has the latest update named Update 3.

FYI, here's the support information for Visual Studio 2012:



Please take note: there is no Service Pack 2 for Visual Studio 2010, as Microsoft is entering the trend of shorter cadence of Visual Studio and Windows.

This means that there will be new release of Visual Studio to be released in 12-14 months period!

For more information, please visit: http://visualstudiomagazine.com/articles/2013/05/10/new-visual-studio-release-cadence-begins.aspx

For me, this is the best opportunity as a developer, always learn something new and very quickly adopt it as needed.

Conclusion? We should focus our energy on Visual Studio 2012, and prepare for Visual Studio 2013!


Sounds agile for me!

Tuesday, June 18, 2013

Team Foundation Server 2010, Team Foundation Server 2012 and Team Foundation Service supports OData

Yes! The title means it, literally!

Now we could connect and query Team Foundation Server and Team Foundation Service work items and many more using OData! Using OData means we are using URLs to directly query.

OData quick background

OData has been around and it’s one of the cool openness initiatives from Microsoft. Originally named as Astoria, then WCF Data Service, now it’s called OData.

It’s simply a specification and libraries to produce data to be visible as URL, and also the consumer of the URLs.

The official website for OData is: http://www.odata.org/

In there, you’ll find numerous library supports for many platforms/OS, also as the server (OData producer) and the client (also called OData consumer). These producer and consumer really fits the nature of OData as web services, therefore it can be seen as open web API to access data.

These are current libraries and OS supports:


What about the real customers/users of OData? There are many producers today, and one of them is the famous Nerd Dinner. I call it famous, because it’s often used as samples of OData usages from Microsoft.

There was Netflix, but Netflix has ceased OData support. Here’s the announcement: http://developer.netflix.com/blog/read/Changes_to_the_Public_API_Program

The use of OData in Team Foundation Server and Team Foundation Service

To use OData on both TFS (the server and the service, what have you), we need to have library supports in the form of Nuget package and also tooling support.

The tooling support is available to download at: http://www.microsoft.com/en-us/download/details.aspx?id=39373

I will not dive into the detail of how to set up OData for TFS, as there are resources from Microsoft to have!

To get started, let’s visit this Brian Keller blog entry: http://blogs.msdn.com/b/briankel/archive/2013/01/07/odata-service-for-team-foundation-server-v2.aspx

This is the official Technet Wiki: http://social.technet.microsoft.com/wiki/contents/articles/15039.odata-service-for-team-foundation-server-v2.aspx

This is the video explanation from Brian Keller: http://channel9.msdn.com/Blogs/briankel/OData-Service-for-Team-Foundation-Server-2010

TFS on the cloud has provided simple OData documentation: https://tfsodata.visualstudio.com/

Now, download the “OData Service for Team Foundation Server v2” libraries for Visual Studio at this link: http://www.microsoft.com/en-us/download/details.aspx?id=36230

Then you'll set to have OData for TFS!

In the libraries above, you’ll see OData for TFS in action as Windows Store app:


Enjoy and happy coding!

Wednesday, May 22, 2013

Speaking for MUGI at University of Mercu Buana

Another speaking opportunity comes! This time an invitation was from University of Mercu Buana. They asked me to provide an introduction to SQL Server 2012.

Again, my main focus is Visual F# but I’m happy to talk about other topic as well.

The schedule was on May 18, 2013 and the venue was at Mosque auditorium inside Mercu Buana surroundings. This is cool, as far as I remember I was never invited to speak in a mosque.

The speaking went quite well, although the audiences were having many background and some of them were non IT.


This provides a real challenge for me as well, to provide a speaking but with explanations as simple enough to be understood by most audiences.

The slides for this speaking is available on my SkyDrive, and I will release the slide to MUGI.

This is my Skydrive slide link: http://sdrv.ms/160RW5R

See you at the next speaking! :)

Thursday, April 18, 2013

My Indonesian KB article about Visual Studio 2012 Update 1 installation has been published for April 2013

Hi again, all!

Busy month again for March 2013! I have been contributing KB articles for you, my dear blog readers and my MUGI community readers!

Thanks to Min Seop, Clarisse Ng, now my KB articles in Indonesia has been published!

The topic is now “How to download and install Visual Studio 2012 Update 1 offline”. And the title in Indonesian is: “Bagaimana cara menginstal Visual Studio 2012 Update 1 secara offline”.

The URL is: http://support.microsoft.com/kb/2838372/id-id

Now, any updates to Visual Studio 2012 will be delivered as “Update” instead of Service Pack. These updates may contain new features, not just bug fixes.

The complete list and overview of Visual Studio 2012 Update 1 is available at: http://support.microsoft.com/kb/2797915

Friday, April 5, 2013

My Microsoft KnowledgeBase (KB) articles have been published for April 2013

Hi all!

March 2013 was quite a busy month. Not just continually writing my blog post on F# series, but I also have volunteered to contribute article for Microsoft Technet Knowledge Base.

Thanks to Lilian and Min Seop from Microsoft, my article is available to be read from April 1st, 2013.

Here’s the link:

  1. How to implement interface in F#
  2. Introduction to F#’s pattern matching

Please visit those links and read it. If you have suggestions and critics, write to me, guys!

Wednesday, March 6, 2013

Reasons to use F# from Brian Mc Namara and Eriawan

Hi there!

I found very precious blog entry of Brian Mc Namara, a team member of F# team at Microsoft.

His blog was originally located at Windows Live Spaces and then transferred to Wordpress.

Now the URL of his Wordpress blog is: http://lorgonblog.wordpress.com/

Brian’s blog is very inspirational, and it’s one of my source of knowledge about F#. One of my favorite entry is “Nine reasons to use F#”.

Here are his reasons:

  1. Units of measure.  If you’re working in domains that use numbers to represent physical quantities like kilograms, meters, and seconds (or pixels versus inches, or dollars versus euros, or …) you can use the F# type system to ensure that the dimensional analysis works out.  Nearly everyone who uses this feature has a “wow” experience where the compiler finds an unexpected bug (it happened for me when working on the 2008 ICFP programming contest).  In certain domains, this kind of static typechecking is a really killer feature. You can learn more about F# units here, here, or here.
  2. Functional programming with .NET.  If you need to author a component that’s especially amenable to functional programming techniques (like game AIs, statistical modeling, symbolic computing, …), and you need to interoperate with SQL, Excel, or XBox, or run in the browser with Silverlight, or run in the cloud with Azure, or do WCF, WPF, or WinForms, or easily talk to your existing C#/VB/C++/COM code, then F# is where it’s at. The .NET platform has great reach and integration with a variety of technologies, and F# extends the platform by providing a way to do first-class functional programming and get seamless integration with all these technologies.
  3. Explorative programming with the REPL.  The F# Interactive tool window makes it easy to execute small bits of code on the fly.  When working with large data sets or mathematical models, this makes it easy to explore the data, play “what-if” games, and directly interact with the data/models in a very “live” way.  When coupled with libraries for data visualization, this enables some really cool stuff.
  4. Asynchronous and parallel programming.  I’ve blogged recently about F#’s unique programming model for writing non-blocking code for asynchronous I/O.  The async programming model also extends to parallelizing CPU intensive work, and F#’s library also makes is straightforward to react to events, use lightweight agents, or run code on the GPU.  (There’s actually tons of content on the web on these topics; in the previous sentence, I just sprinkled in some links to Don’s blog.)  Multi-core is here, and F#’s language constructs and libraries are very well-suited to parallel programming (not to mention some intrinsic advantages of the functional programming style).
  5. Embedded domain-specific languages (EDSLs).  A variety of F# features (including ability to define new operators, currying and function application syntax, quotations, type inference and overall lightweight syntax) make F# a good language for creating EDSLs.  Some examples include FsUnit for unit testing, FAKE for authoring build scripts, FParsec for parsing, and WebSharper for web applications.
  6. Scripting.  Every so often, I need to write a script, but I use perl and batch files infrequently enough that I’m always forgetting the syntax of those.  Nowadays I use F# for a number of scripting tasks, both in the sense of “FSI is the new perl” and for tiny tasks (e.g. if I can’t recall the ascii value of character ‘A’, I just type “int ‘A’;;” into the F# Interactive window).  I know at least a couple folks using .fsx files where previously they would have used batch files or perl scripts.  For me, F# is the first “software engineering” language I know that’s also a good “scripting language”.
  7. A practical language for academia.  Back when I was a college undergrad, the first real programming language I learned in school was Pascal.  (Yes, this was back before C#, or even Java; I’m an old man.)  In university, it seems there’s been a tension between teaching more ‘pure’ and ‘CS-y’ languages and teaching more pragmatic languages (e.g. that you can likely use for gainful employment when you get out of school).  This is still a topic of much debate, but I think we’re in a much better state now, with languages including Java, C#, Scala, Python, and F#, then we were a decade or two ago; there are now a variety of languages that are decent both as “good introductory CS languages” and “useful real-world languages”.
  8. Expand your mind and career.  I think there are a fair number of folks that use C# or VB in their day job, who would like to learn more about functional programming, but find that diving head-first into Haskell is too difficult or time-consuming.  F# provides an avenue to go more gently into the waters of functional programming, leveraging one’s existing .NET and Visual Studio familiarity.  A lot of folks who are just trying F# as a hobby have reported that they’ve learned new strategies/algorithms that they can apply back in their day job (e.g. using C#), hurray.
  9. Fun!  I’m constantly hearing from people how much they enjoy using F#.  Who doesn’t love being able to get a job done and have fun doing it?

I also would like to have his reasons as mine. And I will add my own reasons:

  1. The most succinct programming language on .NET. Yes, anybody might argue F# is not the most succinct, but as far as I know no other programming languages on top of .NET has the succinctness of F#!
  2. Your code is less buggy thanks to the succinctness of F#.
  3. Train you to have functional mindset while not abandoning you OOP and imperative mindset. This is important, as F# is still compatible and interop well with C# and VB.

Any other reasons to add? I also welcome suggestions

Monday, January 28, 2013

Speaking for MUGI at STMIK Tangerang

Hi there!

It’s my nature to share knowledge especially sharing knowledge of my interest on software development, especially .NET. Also being part of MUGI, I enjoyed giving speech as much as I can in my spare time.

This time, I was invited by STMIK Tangerang as part of MUGI goes to campus program. It’s also my honor to represent MUGI, because I have had many knowledge outside my software development interest thanks to MUGI.

The schedule was on January 26, 2013. My topic was ASP.NET 4. I went there with Wakhid Nusa Bakti and Aji Prasetio Wibowo. Aji was giving speaking of Windows 8 topic.


The audience at that time was quite enthusiastic, especially at Q & A sessions after I gave speaking!


And here, Aji, Wakhid and me sitting as speaker panels: (while I was giving demo)


The presentation was full of coding demo, and I also gave copies of MSDN video tutorials for the audiences. There’s also demo in F#, not just in C# to show that F# can be used to code for ASP.NET as well.

See you at the next sharing!