Using Team Explorer Everywhere 2012 Update 1 in Eclipse 4.2 (a.k.a. Eclipse Juno)

Hi there!

In my everyday jobs doing software development tasks (including coding, testing and also managing software requirements), I often use tools to help me. The tools that involves software development teams doing their job to develop software from start to end and also developing future versions of it are often called ALM tools, or Application Lifecycle Management tools.

Before I get down to discussing Team Explorer Everywhere, let me bring you the ALM tools available currently.

These are mature ALM tools currently on market today: (starting from the order of release)

1. IBM Rational Collaborative Lifecycle Management products (yes, they are more than one product under this name)
2. Borland StarTeam for SCM and version control, Caliber for requirement management
3. JIRA (for issue/bug tracking and work item management) and Confluence (for team collaboration) by Atlassian
4. Microsoft Visual Studio Team Foundation Server 2012 with Visual Studio Team Foundation Server 2012 Test Agent

IBM Rational doesn’t have integrated version just like Microsoft has.

Also the offering from Atlassian doesn’t have version controls, although it can be connected to Git or Mercurial. For more info on Atlassian offering, visit this: http://www.atlassian.com/software

The ALM from IBM consists:

1. Rational Requirement Composer (replaces Rational Requisite Pro)
2. Rational Team Concert (will replace Rational ClearCase and ClearQuest)
3. Rational Software Architect (to design business process diagram and other UML, will replace Rational Rose)
4. Rational Quality Manager

For the latest update on IBM Rational ALM offering, visit http://www-142.ibm.com/software/products/us/en/category/SW860

Currently, Rational ClearCase has its own repository infrastructure, not just database. It’s different from Microsoft Visual Studio TFS approach, whereas you can backup the repository by backing up database and setting that TFS used.

I mentioned Microsoft Visual Studio TFS 2012 in the last, because I consider this version can match the maturity of IBM Rational offerings. TFS 2010 can match the IBM Rational, but the requirement management isn’t intuitive enough.

Also even in TFS 2012 I can’t generate or at least make requirement traceability matrix like IBM Rational can.

Those tools above is not interoperable, you have to choose upfront and plan it carefully. Currently, Microsoft supports not just Visual Studio, but Eclipse is also supported for Eclipse 3.5 and 4.2 (Juno).

What about Rational? Currently I can’t find Rational tools from IBM to support VS 2010 or VS 2012. Or if you can correct me, my dear blog reader? I welcome corrections and suggestions!

Using TFS with Visual Studio is easy, using Visual Studio Professional or above edition will have Team Explorer installed, just like this:

It can also connect to Microsoft Visual Studio Team Foundation Service (or simply TFS in the cloud) easily.

But what about Eclipse?

For more info about Juno: http://www.eclipse.org/juno/

The TFS integration tool for Eclipse is freely available to download from Microsoft and it’s fully supported!

The name of the product is Microsoft Visual Studio Team Explorer Everywhere 2012 Update 1. I know, it’s quite mouthful.

Here’s the link to download:

http://www.microsoft.com/en-us/download/details.aspx?id=30661

Any files to download in Microsoft’s download page is free, and it can be a free trial software. But Team Explorer Everywhere is absolutely free and it’s a full working product, not a trial.

But if you want to set up automatically from Eclipse, you can set the Eclipse “Install software” setting to point to Microsoft’s Team Explorer Everywhere download URL.

The detail step by step is also available from the download site, but I’m capturing it for you:

The display will look like this:

Choose it, and install it.

After installing, Eclipse will have a new Team Explorer Everywhere perspective. Open the perspective.

Now you can connect to your own TFS server or connect to Team Foundation Service.

I have used it to connect to my account on Team Foundation Service, the looks is quite similar to Visual Studio Team Explorer:

Now the source control explorer:

Done! But sadly enough, it has no toolbar like the one in VS Team Explorer.

In the future, I will bring more deep conversations and also deep tutorial about ALM using Microsoft Team Foundation Server, after finishing my blog on F#!

[INFO] A hot thread about F# and functional programming is available on Kaskus: about Monad and Type Classes

This is a quoted thread content F# and trends in functional programming in a discussion thread model, please follow my thread (my id on Kaskus is “erilive”) on Kaskus! And it’s available in Bahasa Indonesia!

Hi guys,

If you want to know more about F# and trends in functional programming in a discussion thread model, please follow my thread (my id on Kaskus is “erilive”) on Kaskus! And it’s available in Bahasa Indonesia!

There’s a lot of discussion happens there! And I invite you to join, and I will invite you all of those are advanced or just beginner in functional programming and F#. Some topics are very interesting but quite advanced such as type classes, but there is an easy topic about why functional programming matters.

Here’s the address:

http://www.kaskus.co.id/thread/000000000000000016890387/fpara-programmer-f-dan-functional-programming-disini-yah/

And paragraphs below are samples from the thread:

---

Monad sample

Quote:Original Posted By erilive on http://www.kaskus.co.id/show_post/000000000000000759711105/18/

Monad yang mana gan? Maybe monad, Identity monad, Reader monad, State monad?

Kalau Reader monad di F#, sudah ada yang bahas:
http://codebetter.com/matthewpodwysocki/2010/01/07/much-ado-about-monads-reader-edition/

Dan sepertinya kalau diimplementasikan di bahasa selain F# (kecuali kalau di Haskell) sepertinya akan menjadi kurang elegan.

Monad disini bukan "Monad" di cabang matematika Category Theory.

Kalau memang banyak peminatnya, akan saya jelaskan Monad di thread ini, agan-agan :)

Notes in English: (as translated)

Which Monad? There are Maybe Monad, Identity Monad, state Monad.

Reader Monad sample in F# has been discussed in:

http://codebetter.com/matthewpodwysocki/2010/01/07/much-ado-about-monads-reader-edition/

And if it’s implemented in other language besides F# and Haskell, it’ll be less elegant.

Monad in this context is not direct equals to Monad in Category theory from Math discipline.

Quote:Original Posted By Syinn

silahkan aja kalo mau langsung bahas monad, saya nyimak dulu ...kalo ada yang kurang ngerti , akan saya tanyakan pada anda

ada baiknya bahas yang awal dulu, yakni monad state

Dan sepertinya kalau diimplementasikan di bahasa selain F# (kecuali kalau di Haskell) sepertinya akan menjadi kurang elegan.

btw, saya ingin tahu kenapa om bisa berkesimpulan yang saya bold di atas ? bisa anda jelaskan secara tehnik dan detail?

karena soal keeleganan code pemrograman kan tergantung kreatifitas programmer itu sendiri, apapun bahasa program yang dia gunakan (ini kalo menurut saya lho, om )

Note in English:

He (Syinn) wanted to know about why I told him it’s less elegant.

And here’s my answer:

This is state monad in F# and sample code to use:

module StateMonad

let (>>=) x f =
   (fun s0 ->
      let a,s = x s0
      f a s)      

let returnS a = (fun s -> a, s)

type StateBuilder() =
    member m.Bind(x, f) = x >>= f
    member m.Return a = returnS a 

let state = new StateBuilder()

let getState = (fun s -> s, s)

let setState s = (fun _ -> (),s) 

let Execute m s = m s |> fst

Now, in C#: (taken from http://taumuon-jabuka.blogspot.com/2012/06/state-monad-in-c-and-f.html)

The Bind operator is implemented below:

As you shall see, it’s less elegant!

---

Why IO Monad is “EVIL”?

Syinn asked again! But the topic is about why IO Monad is “EVIL”:

Here’s my answer: (and apologize if it’s quite long)

There is a blog post that describe IO Monad is evil: http://kawagner.blogspot.com/2007/02/why-monads-are-evil.html

And I assume he (Syinn) quoting that blog post although he didn’t mention it.

My definite answer is: IO Monad isn’t evil. According to that post, because value evaluation when designing IO Monad became imperative, and therefore it would break referential integrity. But it’s not! Because the nature of Haskell is non strict (lazy), the timing of the execution is not so important and the reference is not broken.

A simple sample of this is when dealing with iterator of yield in C# (since VS 2005) and in VB.NET (since VB 11 in Visual Studio 2012).

Due to the fact that I/O is side effect, then declaring I/O must be explicit and has to be marked as signature to a part of the “world” that includes garbage collection.

Functional programming, especially the "pure" ones, forces us to be aware and be careful in handling side effect such as I/O, pointer, exceptions.

---

More on this?

You will have it on my part 4, 5 of functional programming series! Watch for my next blog post entry!

Event report on BSI Bekasi Microsoft Technology Update and explaining Asychronous without coding

Hi guys! While I was preparing for Part 4 and 5 of my blog series about F#, MUGI Jadetabek was organizing event at BSI Bekasi about Microsoft Technology update on 13th October, 2012. It is part of MUGI technology community sharing.

The complete event report is already presented by Wakhid Nusa in this blog entry. Now I’ll focus on my participation: acting as MUGI Jadetabek representative and also helping Nicko to deliver presentation of “Introduction to Visual Studio 2012”.

The number of audiences are quite large, it’s about 200 students with roughly equal numbers of boys and girls. The fun side is, the enthusiasm is overwhelming! It’s quite rare to have this rate of enthusiasm, comparing to previous MUGI gathering on other universities/schools.

Other than Nicko from MUGI, we have Agatha Leonita with Office 2013 and Aji Prasetio with Windows 8 respectively.

Here’s the pictures from the event:

Nicko, Agatha, and Aji Prasetio in the pictures below.

 

I was giving short MUGI history and answering questions about Visual Studio:

 

Now a picture of all MUGI’s speakers with Wakhid Nusa excluding Aji: (because Nicko and I have to go after my Visual Studio and Office 2013 sessions done)

One notable questions was “what asynchronous is” when Nicko was delivering Visual Studio 2012 introduction. Although there’s a minor difficulty in Nicko in explaining asynchronous, I was helping giving analogy of a customer ordering and waiting for his food in a restaurant.

Asynchronous means A – Synchronous, it’s not synchronous. Usually we code in synchronous way, in a sequences in our code. This means:

1. Do something and wait until done
2. After number one done, do something else and also wait until done.
3. Do other things after number 1 done first, and then after number 2.

It is well explained, but what happens when you are in a restaurant?

Do you have to wait for your other customer’s order finished eaten and paid? If any restaurants are like these, the experiences will be unpleasant!

So, basically a restaurant is asynchronous:

1. Waiter taking order from customer
2. Waiter is giving order to the chef
3. While waiting for the chef to complete cooking, waiter can take other orders from other customers but there is has to be a continuation point to signal/notify that the cooking is complete, see below
4. Chef is completing the cooking and notifying the waiter
5. Waiter is taking the cooked cuisine and giving it to the customer in a step one.

So, the experience is pleasant and satisfactory, because the waiter isn’t idle waiting for the cook to be finished and he/she can take other order from other waiting customers!

We have had asynchronous programming model in basic BCL threading, Windows Forms, WPF and ASP.NET. But sadly, it’s not intuitive and easy to write.

Now the horrible experience of writing async code is simplified using async keyword in C# and VB in Visual Studio 2012.

This is a sample of using async to get web content asynchronously: (from MSDN Library)

The code after await getStringTask is the continuation, but it’s quite easier to write because it feel synchronous!

But F# already has this way before VS 2012! It was introduced in F# 1.8 and F# asynchronous workflow was also inspiring async in C# and VB.

This is F# sample from MSDN:

In the sample above, it’s combined with parallel programming with Async.Parallel! Watch async in action in my next blog series about F#, guys!

For more information about async in C# and VB in Visual Studio 2012, visit:

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

Lastly, keep sharing your knowledge guys! Go MUGI!

Hello and intro to my lonely F# blog

Hi, blog readers! This is Eriawan Kusumawardhono’s blog of F#, although may contain C#, Visual Basic, and other things such as Visual Studio 2010 and above.

This blog can be seen as mirror of my other blog on MUGI (a community website of Microsoft users and developers in Indonesia), http://mugi.or.id/blogs/eriawan because the server of we are using  are undergoing heavy maintenance.

This blog, because of the nature of F#, will also contain some fundamental concept of functional programming.

The next blog series will provide a glimpse of my future ebook on F#.

Enjoy!