Current state of Visual Studio releases [January 2016]

Hi my dear blog readers!

The “Current state of Visual Studio releases” series has been quite in active for about 4 months. I know this is supposed to be updated regularly, but unfortunately there are very rare notable news and updates of Visual Studio and Microsoft’s Developer Division.

Also the series got a bit delayed, because I was focusing on previous Lambda Jakarta coding dojo meetup.

From the beginning of December 2015 to 20th January 2016, these are the updates of Visual Studio:

1. Support period ending for .NET 4, 4.5, and 4.5.1
2. The release of Visual Studio 2015 Update 1 (on November 30, 2015)
3. Node.js Tools for Visual Studio version 1.1 released (on November 17, 2015)
4. First preview of Visual Studio Java Language Service for Android

Now, let’s discuss those three! Except for the last one (number #4), I haven’t got the chance to fully use it.

This is still in preview, for more information please see the blog: https://blogs.msdn.microsoft.com/vcblog/2015/11/06/java-debugging-and-language-support-in-visual-studio-for-android/

Now, let’s start!

Support ending for .NET 4, 4.5 and 4.5.1

The original announcement is here: http://blogs.msdn.com/b/dotnet/archive/2014/08/07/moving-to-the-net-framework-4-5-2.aspx

This simply translate as “Microsoft will not provide supports anymore for .NET 4.0, 4.5, and 4.5.1 and this include hotfixes for these releases”. The next message is simply please update to at least .NET 4.5.2 or even better, 4.6.

The follow up of the original announcement is here: https://blogs.msdn.microsoft.com/dotnet/2015/12/09/support-ending-for-the-net-framework-4-4-5-and-4-5-1/

The interesting fact is from the link above is:

Applications targeting a .NET Framework version that is no longer supported will not need to retarget or recompile to a newer version as they can be run on a later .NET Framework version. The .NET Framework 4.5.2 and higher versions have higher compatibility, provided by a newer feature called “quirking”. Quirking is a pattern in which a .NET Framework version maintains the semantics of earlier versions, while including updated implementations. The .NET runtime knows which of these semantics or quirks to execute depending on the .NET Framework version that the application targets. More information on migrating an application can be found on the Migration Guide to the .NET Framework MSDN article.

Put it simply, it matches with my translation above. I believe this will bring more burden on the enterprise IT operations especially those that focusing on premises (instead of cloud such as Azure), because .NET 4.5 is still quite new for them.

It’s quite new for them, because .NET 4.5 was released in 2012 (with the same release date of Visual Studio 2012, and also Windows 8/Windows Server 2012). Fast forward to now, end of year of 2015, only less than 3 years but they have to immediately upgrade. Less than three years of platform update is inevitable,

This end of support is not just for us, developers. For those develop .NET applications that runs on Azure, the upgrades on Azure are necessary. Fortunately Microsoft has provided updated images (mostly in form of Virtual Machines) that more focusing on .NET 4.5.2 and above (including .NET 4.6).

Visual Studio 2015 Update 1 RTM

This release although it might seems a service release, it really contains many new things.

These are new features brought by Update 1:

• Visual C#
• Debugging enhancements (Visual C++ and IDE aspect)
• Tools for Apache Cordova (now Update 5)
• Tools for Universal Windows Apps version 1.2

And many more! For complete list of release notes, visit: https://www.visualstudio.com/news/vs2015-update1-vs

Let’s visit some of the new features:

Visual C# new features

This Update 1 brings you C# Interactive Window and C# scripting API. This C# interactive window is very much like F# interactive window, except it has these two quite subtle differences: it has intellisense and type coloring!

If you are wondering what to do at the C# interactive window, just type “#help” like above.

And now we have C# scripting API. Unfortunately, the documentation of C# scripting API is still incomplete and I could not test it further.

One thing is still missing: VB.NET Interactive window! Unfortunately, we won’t see VB.NET interactive in Visual Studio 2015 at all, even after Update 1.

 

Debugging and diagnostic enhancements

In VIsual C++, now we have support for Edit and Continue for /BigObj. This looks like minor feature but this is very important, because it enables debugging with Edit and Continue support for WIndows Store applications that’s written in C++.

In Visual C# and Visual Basic, now we have “Go to implementations” feature when you activate context menu in the source code window. This item will display the implementation of the object you want to observe, not just having knowing “Go to definitions” that was available since VS 2002 (also called Visual Studio .NET 2002).

Yup, it’s a minor addition but it’s useful!

There’s also enhancements on Code Analysis, but unfortunately it’s not for Visual Studio Express Edition.

Tools for Apache Cordova (a.k.a. TACO) Update 5

The notable feature is support for iOS 9 and experimental support for Android M, a.k.a. “Marshmallow”. Now TACO is maturing well. The overall experience of using this release is much better than previous releases, including better performance especially responsiveness of the emulators when running Cordova applications.

Beginning with this Update 5, the Node.js will only focus on Node.js version 5. So please update your Node.js installation as well to focus on Node.js 5 and above!

For more information on this TACO update 5, visit: http://taco.visualstudio.com/en-us/docs/release-update-5/

Node.js tools for Visual Studio version 1.1

This is a very useful tool, and sometimes I use this tool to debug certain Node.js package or applications. Having Node.js support in Visual Studio is a very nice feature although this tool is available as Visual Studio extension:

For more information, please visit the official repo of Node.js for Visual Studio: https://github.com/Microsoft/nodejstools

Yes, it’s OPEN SOURCE!

After you download from the Visual Studio Extension and Updates (or you can get from VS Gallery), simply install the MSI:

The installation for this release, 1.1.1 will take about 5-7 minutes on VS 2015 Update 1.

One thing you must remember: it needs Node.js at least version 0.91 but it’s recommended to install Node.js 5.

Now, Visual Studio 2015 will have these new project templates: (under TypeScript)

Now, enjoy and I welcome discussions!

Presenting F# at Lambda Jakarta’s Coding Dojo January 2016

Hi guys!

It’s now community time! I have been active in mostly these two communities, MUGI and Lambda Jakarta.

This time, it’s for Lambda Jakarta. For quick overview of Lambda Jakarta, please read my previous blog: speaking on Lambda Jakarta and welcoming new members on May 2015.

The agenda is having a Coding Dojo in January 16, 2016 that showcases solutions to a specific problem. Thanks to KMKLabs that generously provides us the place to have this meetup!

This is the agenda link on meetup.com:

http://www.meetup.com/Lambda-Jakarta/events/227571071/

These are the language list that joined the coding dojo:

• F# (brought by me)
• Scala (brought by Herdy Handoko)
• Haskell (brought by Abdullah)
• Scheme
• Elixir
• .. and more (including Clojure!)

We have relaxed the coding dojo a bit, as we focusing on functional programming languages but we are welcome participations from attendees

This means, we got a lot of contributions with lots of different programming languages. Bring it on!

The problems we’re going to solve are FizzBuzz and Dice Roll. Because of our limited time, we only had the chance to present FizzBuzz solutions.

You may read the problem description of FizzBuzz and Dice Roll on the event website. The interesting problem is the FizzBuzz, as it’s often asked at interview of software developer (see this site and this Jeff Atwood’s blog for example).

FizzBuzz was a child’s math puzzle, it’s simply saying Fizz for any number that is divisible by 3, and Buzz for any number divisible by 5, then FizzBuzz for any number divisible by 3 and 5.

put it simply: 3 – Fizz, 5 –Buzz, 15 – FizzBuzz

But then there are various solutions to the problems, as we are trying to solve with the languages we have at each of us disposal.

We have intro from Tito, developer of KMK Labs (the place and the host):

I have the chance to present F# as my language to solve. Here, using Visual Studio projected to a large LED display:

Here’s the code in F#, you can write this using F# pattern matching:

Here’s the result display on F# interactive:

We also have Herdy, Abdullah, and others to present as well:

 

The next meetup? Just stick around at Lambda Jakarta meetup website: http://www.meetup.com/Lambda-Jakarta/

See ya!

What’s new in F# 4.0 in Visual Studio 2015

Hi my blog readers!
Today I’m going to share information about F# in Visual Studio 2015.
When Visual Studio 2015 was first released, F# was also released as F# 4.0. Put it simply, Visual Studio 2015 has F# 4.0 in it, or you can view it other way: F# 4.0 was released at the same time as Visual Studio 2015 released.
A complete list of F# 4.0 new features, enhancements and bug fixes are available in F# Github repository in the form of markdown page: https://github.com/Microsoft/visualfsharp/blob/fsharp4/CHANGELOG.md
There many nice features and bug fixes! But for me, based on the previous link, the nice parts of new features of F# 4.0 are:

1. Constructors can be treated as first class functions
2. Support for high dimensional arrays is now in sync with .NET 32 dimensions array. Previously F# only supported up to 4 dimensional arrays.
3. Synchronize of “API parity” for List, Array, and Sequence, including additional new APIs: chunkBySize, contains, except, findBack, findInstanceBack, indexed, item, mapFold, mapFoldBack, sortByDescending, sortDescending, splitInto, tryFindBack, tryFindIndexBack, tryHead, tryItem, tryLast
4. Slicing support for List
5. Supports for VS debugger for debugging F# script

Important notes:

1. Slicing support for List is quite comfortable, but please be careful that this List is F# List, not the original .NET’s System.Collections.Generic.List. F# List is implemented as linked-list, this is why the original F# List has no inherent support for index before F# 4.0. Actually and it’s natural to have an index, because slicing support requires to have an index.
2. High dimensional arrays are not available in all of the F# APIs. There’s no API for manipulating arrays that has dimensions above 4 dimensions.

For more information about the general enhancements, see this blog post: http://blogs.msdn.com/b/fsharpteam/archive/2014/11/12/announcing-a-preview-of-f-4-0-and-the-visual-f-tools-in-vs-2015.aspx
Tomorrow I’ll discuss the new features above with some samples!

Giving quick intro on functional programming on Lambda Jakarta October 2015 Meetup

Hi guys!

Now it’s community time! To be specific, Lambda Jakarta meetup time!

This time (as suggested on previous meetup, on my blog, and on Lambda Jakarta’s Slack group) Erik Dominicus and I are going to give separate presentations on the same topic: introduction to functional programming language.

The place was still the same, MNC building, but the date was 31st October, 2015 on 12.30 PM (after lunch).

Yes, we both deliver the same concept but we decided to give different ways to deliver these presentations.

I focused on giving intro with the past background of common non functional programming introductions including OOP (hence imperative), and then gently driving the mindset into functional. Eric focused on giving intro directly on conceptual principles on functional programming.

The invitation page on Lambda Jakarta’s meetup of October 2015 page neatly described this:

Yes, I focused on gentle intro with introduction from non functional programming.

Introduction to functional programming will be delivered and presented as gentle intro into the concept regardless of functional programming languages (language agnostic). This quick intro will get you jumpstart with relevance to other todays programming paradigm such as OOP and imperative without hurting your brain

This is the excerpt from my slides:

..and we all know these facts:

Yes, functional programming should be fun! Unfortunately, I didn’t have the chance to be captured as video. The next meetup will try to repeat my talk and it’ll be video captured

These are the pictures:

..and there’s more on Lambda Jakarta’s meetup page for October 2015

I was so excited to have many feedbacks and questions in the middle of my talk! One of them was asking about asynchrony and synchrony concept. Although they are concerned and closely related to parallel programming, asynchrony and synchrony are not parallel programming concept. Asynchrony, synchrony are just part of concurrent programming, and parallel programming also part of concurrent programming.

This is also unfortunate consequence of common fresh graduate of computer science faculty in Indonesia: the curriculum keep mixing wrong concepts, and always leaning more on “industrial trend” based on not so official TIOBE index.

Very well, this is our responsibility to change this, right?

We have agreed to have next meetup soon after the TechinAsia event (11th November). Stay tuned on Lambda Jakarta’s meetup and Slack website!

UPDATE:

This is my slide for the presentation: http://1drv.ms/1X07sFT (feel free to download)

I’m going to give presentation on TechDays 2015 Indonesia

Care to know about Git and Github support coming inside Visual Studio 2015?

Catch me at Microsoft Indonesia’s TechDays 2015 event!

Register now at http://aka.ms/techdaysid

See you there!

Attending Lambda Jakarta September 2015 meetup

Hi guys!

In this blog entry, this is my story about helping to organize meetup of Lambda Jakarta.

The meetup was held on 19th September at MD Entertainment Tower 2.

The link is: http://www.meetup.com/Lambda-Jakarta/events/225037500/

The place of this meetup look weird, it looks like a building with lots of venous blood pumping;

The agenda is:

• Presentations from Erik Dominicus and Dicky Arinal
• General functional discussion,
• Meetup formalization and next steps

Presentations from Erik Dominicus was quite great. He presented a quick intro to Haskell, a quite old functional programming language that still influences many functional programming language today including ML, F#, Scala.

Dicky Arinal presented a lightning intro to concurrency in networking. A quite tedious and technical talk, but quite refreshing to know deep into what’s going on at multithreading in networking world.

The formalization was originally to discuss what will be the next meetup, but then the discussion crystalized onto one need of having online collaboration. After brainstorming, I proposed to use Github and Gitter to have chat. But most of the audiences were familiar with Slack, so I decided to jump in and set up Slack:

The Lambda’s Slack link: https://lambda-jakarta.slack.com/messages/general/

The collaboration is nice, you should try it! It’s quite the same as Gitter, but unfortunately not all of us can directly join the confirmation, you have to be invited first.

Here is the conversation at #general channel:

Now we have more channels for specific interests:

Of course, there’s F# in #fsharp channel

Now the organization of Lambda Jakarta has been set up as a repo in Github! <link is: https://github.com/Lambda-Jakarta >

Go Github! At the picture above, I also set up a repo to contain all of the source code sample to teach functional programming. This meetup was fun!

This the shoot from the meetup:

The next meetup has been also scheduled for 31st October 2015. Guess what? I’ll present an intro to Functional Programming without hurting your brain, and Erik will present an intro to Functional Programming but with totally noob view!

Current state of Visual Studio releases [July 2015]

Hi my blog readers! I know, this blog installment should be out at before 24th July, but there were some exciting news to tell!

This is the fourth installment of Visual Studio releases update. In this installment, the updates are not so much like previous (on May 2015) but it’s very worthy to know!

These are the updates:

• Visual Studio Team Foundation Server 2015 RC2 release
• Visual Studio 2013 Update 5 release
• Visual Studio 2015 release

Now let’s talk about those releases!

Visual Studio 2015 RTM

Yes, Visual Studio 2015 has been released on 20th Jluy! I have described the what’s new on Visual Studio 2015 RC on the previous Visual Studio updates, now the RTM add this nice additions:

• New support for high resolution icon for VS extensibility. This means VSX icon will scale nicely on high resolution monitors. There’s also Nuget package of Visual Studio extensibility, so VSX updates are less dependent on the standalone installer of VS SDK (like VS SDK before VS 2015)
• Support for TypeScript 1.5. This also means support for features in ECMA 6, the current standard of Javascript.
• Improved user account management of Visual Studio Online account and Git, also provide switchable profiles. Sweet!
• Improved user account management for Azure AD, including supports for multiple Azure AD
• Diagnostic tool that supports debugging of LLDB, GDB that usually used on GNU compilers. Now this addition requires some deep dive explanation, I’ll try to explain this on separate blog post after this
• Bing powered compiler help. Honestly, I haven’t tried this yet but I’ll try to tell my experience on this later
• … and many more!

More detailed description is available at: http://blogs.msdn.com/b/visualstudio/archive/2015/07/20/visual-studio-2015-and-visual-studio-2013-update-5-released.aspx and also specifically at: https://www.visualstudio.com/news/vs2015-vs

Also there are videos to watch at the launch of Visual Studio 2015: https://channel9.msdn.com/Events/Visual-Studio/Visual-Studio-2015-Final-Release-Event

I encourage you to check those videos!

Visual Studio 2013 Update 5

Not much is new on this release, but these are the most notable additions:

• support for Team Project renaming, including sync with local workspace. Sweet!
• Additional query token of “current iteration”
• Cloud based load testing. Sweet!! This feature is very worthy to have, as it’s easier to have load test in cloud instead of playing around with on premises load test.

For more information on VS 2013 Update 5, visit VS 2013 Update 5 release notes: https://www.visualstudio.com/news/vs2013-update5-vs

To download VS 2013 Update 5, go here: https://www.visualstudio.com/downloads/download-visual-studio-vs

 

Visual Studio Team Foundation Server 2015 RC2

Finally, Team Foundation Server 2015 (a.k.a. TFS 2015) is not just feature complete, but it’s nearing RTM release!

From Brian Harry blog post:

Our plan had been that the Release Candidate we shipped at the end of April would be our last public pre-release and that mid-July would be our RTM date.  About a week ago, I made the decision to change the plan.  Instead, we are shipping a “Release Candidate 2” now and will RTM as soon as we are ready after that.

This means TFS 2015 is not released at the same time of Visual Studio 2015 and it’ll be definitely released after Visual Studio 2015 RTM.

One thing for sure is that the support for team project rename is available on this TFS 2015 RC2, and it works the same as in VS 2013 Update 5.

To download TFS 2015 RC2, visit: https://www.visualstudio.com/downloads/download-visual-studio-vs

But by the time TFS 2015 RTM released, the download will be replaced by RTM version of TFS 2015.