
The .NET Language Strategy - benaadams
https://blogs.msdn.microsoft.com/dotnet/2017/02/01/the-net-language-strategy/
======
Analemma_
I also want to commend Microsoft for continuing to support VB and not
succumbing to the whims of sneering hipster programmers who consider it
beneath contempt (see the second comment on that article for a good example,
with a classy response from MS). VB is a thing that a lot of people rely on,
and some even like, and doesn't deserve to be kicked to the curb.

~~~
mpeg
I wrote my first non-toy lines of code in VB6, with a (pirate) copy of the IDE
that I had to ask for as a request to a dude that sold cds in a public park.

At that time, I only had a C/C++ compiler that I didn't know how to use
(because I had no internet and no standard library / STL docs). The MSDN
library that was preloaded in the cd was an eye opener, and the visual
components made it easy to experiment.

I would probably work in a restaurant today, if it wasn't for that cd.

~~~
discreteevent
I worked in a start-up straight out of college where I had done C/C++. We
decided to try out this Visual Basic to see if we could get things done more
quickly. VB 3.0. I was blown away by how quickly you could do things even
though the language made it hard to organise any kind of structure when things
got bigger. We did a lot of work in it and I assumed something like it was the
future of programming.

Then the start up went bust and I was back to C++ before any newer version of
VB came out. They really got reusable components right. I've never had an
experience since where there is such a huge jump in productivity with a new
technology.

~~~
fiddlerwoaroof
I'm not really sure of the timeline, but I think Delphi pioneered the
"reusable components" paradigm and VB was Microsoft's entry into the market.

~~~
ryanhuff
Delphi came after VB3. VB3 had "custom controls" called VBX (Visual Basic
Extensions), which were the reusable components. It was the precursor to OCX
and ActiveX controls.

~~~
probablybroken
Yes - I migrated from VB -> Delphi - one of the big advantages at the time was
you could compile a small executable that didn't require you to distribute
several additional disks of vb runtime DLLs with your software.

------
mkozlows
So the big change there is to VB, right -- instead of being a language co-
equal to C#, they're refocusing it to be beginner-focused, and are explicitly
saying it won't have the same capabilities as C#.

I think that makes a lot of sense -- it was always weird to have two near-
identical languages to choose from -- but at the same time, I wonder if VB.NET
isn't already too complex to be an accessible language for beginner-
programmers in the way that PHP or VB6 were.

~~~
hacker_9
I learned on VB.Net maybe ~15 years ago now, and back then all the english
like 'end sub' and 'end if' really really helped me understand the code.
Honestly languages that used brackets looked like voodoo to me at the time. Of
course later when I understood that brackets were faster to write and conveyed
the structure just the same, I converted and became a sneering hipster.

~~~
cm2187
I don't think anyone has ever typed _End If_ in visual studio. The VB IDE
always had very proactive statement completion, that the C# IDE only recently
matched. All you end up typing is "for i=1 to 10", press enter, not worrying
about the casing and the IDE does the rest. To me the quality of the IDE makes
50% of the quality of a language and the VB.net IDE was superb.

~~~
Jaruzel
tsk! :)

>> For I _as Int32_ = 1 to 10

I may be a VB.NET stalwart, but I have evolved to ensure my code is clean and
properly declared, and I wish that all my VB.NET colleagues had done the same,
then maybe it still wouldn't be seen as C# ugly step-sibling.

Why don't I switch to C# ?

1) I don't code professionally these days, only as a hobby.

2) I can't see the point of having to put semi-colons at the end of lines,
when you immediately follow them with CRLF anyway.

3) Curly brackets are too easy to miss in the middle of code for these old
eyes.

Right now, there's almost no app that's written in C# that can't also be
written in VB.NET.

~~~
cm2187
I agree with your points except for

    
    
      For i as Int32 = 1 to 10
    

There is nothing loose or unambiguous about type inference

    
    
      Dim i = 10
    

is absolutely unambiguous, strongly typed and elegant. The For i = 1 to 10 is
just doing the same in a loop.

~~~
Jaruzel
I think I had gotten stung previously with VB6s loose typing (everything as a
generic object unless declared otherwise), so when I switched to VB.NET I made
a point of declaring everything (and still do).

~~~
cm2187
yeah it took me a while to get rid of bad VB6 habits too. Hungarian notation,
specifying byval in front of every arguments in a function, not relying on
type inference, etc.

------
nathanaldensr
Good on Microsoft for writing about their strategy in such a clear, concise
way. More of this style of writing, please, Microsoft! C# is, indeed, a real
treat. I've been in love with it since 2001 and that shows no signs of
changing any time soon.

~~~
hacker_9
Honestly I wish decent transpilers existed in life so I need never use another
language.

------
arthurjj
It's nice to see their strong continuing support for F#. I'm no longer in the
.NET ecosystem but when I was learning F# and using it day to day was some of
the most enjoyable paid programming I've done

~~~
MichaelGG
I wouldn't call it strong continuing support. F#'s been a second class citizen
both in resources given and marketing support. Community effort is great, but
as long as MS pushes C# as the flagship language instead of giving it the
equal-or-lesser footing it deserves, F# can't truly pull ahead.

It's good to see C# catching up with the past decades of language research.
Maybe it's MS's DNA - they're still heavily pushing C++.

Tooling is the only real reason to ever use C# over F# - C# just doesn't do
much (anything?) better. That, and legacy/enterprisey dev.

Heck, C# 7's tuple support is exactly what F# used to do, but then capitulated
to MS's idea of making System.Tuple, a reference (heap allocated) type. Now in
C# 7 since they finally got around to being a bit serious, they implement a
new value-type tuple.

I guess we should be happy for any F# support we get. And indeed, tooling for
functional languages is poor in general, so F# certainly leads...

~~~
MadsTorgersen
You're seeing us strike a balance here. As I point out in the post, there are
millions of C# developers, and tens of thousands of F# developers.

However, we think F# has awesome growth potential, and is great for .NET in
general. So while we can't defend spending the same resources on it as we do
on C#, we want to do what it takes to nurture it and keep it healthy and
growing.

Being on the inside at Microsoft over the past years, it's been great to see
more and more of the organization think of F# as part of the family.

~~~
oblio
In my opinion Microsoft should focus more on base tools for F#, such as
Roslyn, integration with dotnet core, etc.

Integration with Visual Studio is nice, but if the language is to be adopted
in hacker circles, without major Microsoft investment, it needs to provide
very solid and flexible tools on top of which the community can build awesome
things.

Example of small things Microsoft can help with: as far as I can see Nuclide
doesn't work with dotnet core (only Mono). Throwing 1-2 devs that way would
pay good dividends, in my opinion.

~~~
wluu
> Example of small things Microsoft can help with: as far as I can see Nuclide
> doesn't work with dotnet core (only Mono). Throwing 1-2 devs that way would
> pay good dividends, in my opinion.

I don't know anything about Nuclide, but if they want to work with dotnet
core, they should look into working with omnisharp-roslyn[0]. VS Code[1] and
Atom[2] both have extensions that work with it.

> In my opinion Microsoft should focus more on base tools for F#, such as
> Roslyn, integration with dotnet core, etc.

I think there's already work underway for F# support for dotnet core[6].

As far as F# support for editors go, have a look at ionide[4]. They only have
extensions for VS Code and Atom at the moment.

> Integration with Visual Studio is nice, but if the language is to be adopted
> in hacker circles, without major Microsoft investment, it needs to provide
> very solid and flexible tools on top of which the community can build
> awesome things.

Have you seen omnisharp[5]? If so, what's missing from that?

[0] [https://github.com/OmniSharp/omnisharp-
roslyn](https://github.com/OmniSharp/omnisharp-roslyn)

[1] [https://github.com/OmniSharp/omnisharp-
vscode](https://github.com/OmniSharp/omnisharp-vscode)

[2] [https://github.com/OmniSharp/omnisharp-
atom](https://github.com/OmniSharp/omnisharp-atom)

[3] [https://github.com/Microsoft/language-server-
protocol](https://github.com/Microsoft/language-server-protocol)

[4] [http://ionide.io/](http://ionide.io/)

[5] [http://www.omnisharp.net/](http://www.omnisharp.net/)

[6] [https://github.com/dotnet/netcorecli-
fsc](https://github.com/dotnet/netcorecli-fsc)

~~~
enricosada
About F# and .NET Core, you can read more info (usage/bugs/workaround) in the
wiki [https://github.com/dotnet/netcorecli-
fsc/wiki/](https://github.com/dotnet/netcorecli-fsc/wiki/)

The only ide who support f# and .net core is VSCode (with Ionide extension who
add f# support)

see

\- [https://github.com/dotnet/netcorecli-fsc/wiki/.NET-Core-
SDK-...](https://github.com/dotnet/netcorecli-fsc/wiki/.NET-Core-SDK-preview2)
for LTS of .net core 1.0 (project.json)

\- [https://github.com/dotnet/netcorecli-fsc/wiki/.NET-Core-
SDK-...](https://github.com/dotnet/netcorecli-fsc/wiki/.NET-Core-SDK-preview4)
for msbuild based (latest bits)

------
ktRolster
It's worth mentioning that another reason C# is popular is because of the
strong commitment to backwards compatibility. I can write something in C# and
be fairly confident that it will still work a decade from now. That kind of
reliability makes me willing to invest significant capital into C#
development.

~~~
melling
How much cruft is in the language because of backwards compatibility?

Java couldn't do generics right, for example, because they didn't want to
break compatibility. C# seems to be adding a lot of improvements, but would it
be better if they could break compatibility?

~~~
hacker_9
Probably the big one is non-nullable types [1], aka 'The Billion Dollar
Mistake', which would break everything.

[1]
[https://gist.github.com/olmobrutall/31d2abafe0b21b017d56](https://gist.github.com/olmobrutall/31d2abafe0b21b017d56)

~~~
hvidgaard
If that is to be done, there needs to be some legacy settings for the
compiler. I'll happily, trade inconvience for the ability to completely
abolish null from my code. I already use a Maybe pattern to avoid returning
null, but I cannot avoid checking for null because it's so ingrained in the
standard lib.

------
mamcx
Again about F#:

\- F# is poor for relational databases. (Also, I try several ORM-ish/type
providers but only "work" for sql server, and in windows). \- F# is poor for
web projects and \- F# is poor for mobile development.

I'm sticking with F# because I'm that much against C-based syntax, not because
I logically noted that C# is the only language that truly matters in .NET and
I waste more time I wish to trying to solve everything with F#. Also, I'm a
solo developer.

BTW, I use python, F#, swift, obj-c, delphi and have used Visual FoxPro and
others languages that are smaller and expected to have limited support. Among
all of this, F# is the one that cause more trouble (because tooling and
ecosystem).

But is just a joy when things work. And the _massive reduction_ in code pay
for it. It only need some love to polish around the edges.

~~~
justanotheratom
I am curious whether you think F# is poor as a language for web/mobile
development, or is it the F# tooling for such development that is lacking?

~~~
enricosada
well, some options for mobile

\- xamarin works with f# and support it:
[https://developer.xamarin.com/guides/cross-
platform/fsharp/f...](https://developer.xamarin.com/guides/cross-
platform/fsharp/fsharp_support_overview/)

\- use react native (with fable to transpile f# -> js):
[https://github.com/fable-compiler/fable-react_native-
demo](https://github.com/fable-compiler/fable-react_native-demo)

for web you can use:

\- suave ([http://suave.io](http://suave.io))

\- aspnet core (or aspnet core mvc)

both works with .NET, .NET Core and Mono

~~~
mamcx
I'm aware of all that options, and have tested them. In fact, I have tried to
use xamarin+f# for mobile for a year.

Now is a better (even have F# templates!) but is clearly a second class
citizen.

\--

Is not the case of Core that F# integration is black magic, or this has
changed in last release? All apis work now for F#? For web I try like 6 months
ago and only suave was more or less usable (however, is hard to find how solve
some stuff. NOTHING (in the open source options I test) is close to
Flask/django in this case, and asp.net was sub-par when I test it.)

\--

I also agree that F# need more push from MS. My complaints, like much others,
are about things that just need more polish and tooling - and if it get more
competitive in performance with C#, better -. So I think is good to see this
.NET strategy and think F# have a good future, to the point that F# _is the
only reason_ I come back to .NET.

Is only, I wish not just a good future. I want a AMAZING future!

------
Jaruzel
Seeing as this is a comment thread all about VB, an anecdote:

A few weeks ago, I decided to convert the 300 or data CDs and DVDs to ISOs -
there's no point keeping large stacks of discs around these days - especially
now that most OSs allow you to natively mount ISOs as virtual drives.

I wanted a quick and easy one-click ISO creator (for Windows), so hunted
online for one, and couldn't find a good free one, so turned to Visual Studio
to knock up my own utility (as I tend to do often).

Not wanting to waste too much time on this (after all it's a one-time ripping
project) I found some C# and VB.NET partial code examples of how to stream the
data byte by byte off the disc, and into an ISO file.

Try as I might, I just could not get the code to work. Again not wanting to
waste too much time, I remembered I'd also seen some VB6 code snippets during
my searches.

I fired up a VM that has VB6 installed (as I never use VB6 anymore), and threw
in the snippets, and 10 minutes later I had a rough cut of the utility ripping
it's first disc to an ISO.

People are very quick to decry older technologies, but if they still work, and
take less time to use, then where's the harm?

Screenshot of the util (that happily converted over 300 random data discs over
the space of a few days, without error):

[http://www.jaruzel.com/files/dvd-to-
iso.jpg](http://www.jaruzel.com/files/dvd-to-iso.jpg)

~~~
acqq
I agree with you. If I remember correctly there is also a x86 debugger written
in VB. And I claim that those who write C++ by using all the "boost" they can
in fact just use too much energy to write VB-style in C++ (or Python style, or
Java style). And once they achieve that, having a separate allocation for
everything, reference counting etc. even the performance converges, once the
allocation patterns are similar.

All that being said, for the task you needed, have you seen ImgBurn? It's a
native application, written in Delphi. There's a button "create the image file
from disc."

[http://imgburn.com/index.php?act=screenshots](http://imgburn.com/index.php?act=screenshots)

~~~
Jaruzel
I have ImgBurn installed, and use it a lot, but i needed the 'play a sound
when done' and 'eject when done' features - as they really help with bulk rips
if you are doing something else at the same time.

I also know from experience, that the simpler the UI, the faster repetitive
bulk tasks become - years ago I wrote something similar for Audio CDs when I
was ripping my (at the time) 500+ music CD collection.

~~~
acqq
> but i needed the 'play a sound when done' and 'eject when done'

I believed both are present in ImgBurn, see Settings/Read/Page 2 "batch mode:
eject tray before next read" and Settings/Sounds "Play sound after read"?

Wouldn't you in ImgBurn just have to put the next disc once the previous is
finished, it would even detect when you close the tray and continue
automatically with the automatic name, you wouldn't have to click anywhere in
the GUI?

------
jimmcslim
It's unlikely, but it would be great if Microsoft would take ownership of the
.Net port of Clojure. If there are two official object-oriented languages in
the .Net stable; C# and VB.NET, why not two official functional as well; F#
and Clojure?

Given Arcadia, the Clojure bridge to Unity, and Microsoft's interest in Unity
via its Unity Tools, there might be some synergy there.

~~~
nothrabannosir
C# and vb.Net are not so much two languages as they are two grammars for the
same language. Their ASTs are practically equivalent, bar some minor vb
idiosyncrasies, holdouts from the VB6 days. I would be surprised if there were
any organizational overhead to speak of for MS in maintaining the two.

Clojure and F# are fundamentally, semantically different.

(not arguing for or against, just giving some background)

~~~
marssaxman
_I would be surprised if there were any organizational overhead to speak of
for MS in maintaining the two._

I sure wouldn't, because I worked on the VB.NET compiler team back in
2008-2009, and "organizational overhead" was pretty much the whole game. The
VB and C# compilers were completely separate codebases, managed by parallel
but non-overlapping teams of engineers. We never touched the C# compiler's
codebase, and the C# people never touched VB. (I did once read through a piece
of the C# compiler source code, to see how they'd implemented a feature I was
supposed to be reimplementing for VB, so I could be sure to use the same
semantics: but that was it.)

We had lots of meetings, though. Oh, god, so many meetings. _So much_ time
burned keeping all those parallel projects in sync. Whatever commonality the
languages have occurs through endless soul-crushing hours of almost-pointless
meetings sorting out how these two separate pieces of software are both going
to be modified to do pretty much the same thing, with almost exactly the same
syntax. Every new feature had to be designed twice over, implemented twice
over, tested twice over, and documented twice over. They may look like twin
languages, but the illusion is maintained via massive, ongoing investment of
sheer brute force man-hours.

Maybe things have changed since I was there, but it's really difficult to
imagine how that could happen. The VB compiler was effectively legacy code, a
horrible creaky mess of ancient patched-together bullshit, and nobody wanted
to touch it any more than necessary for fear of breaking something.
Refactoring was totally out of the question. I cannot imagine an organization
as sclerotic as devdiv managing to rally the effort it would take to rewrite
it - safely! - such that the VB and C# codebases could be combined far enough
that they would no longer need to have a separate VB compiler team.

~~~
pzone
This is one of the most fascinating "how the sausage is made" posts I've read
on HN.

------
justanotheratom
More love for F# please.

~~~
beefydude
It is coming!

We love F# and it continues to be both an inspiration to other languages at
Microsoft, as well as API developers.

~~~
keithnz
this would be great, with more and more people learning about functional
programming techniques, C# with a functional leaning is really nothing
compared to F# with support for OO. It's like the premium language from MS but
feels not so loved.

------
smacktoward

       I met a programmer from an antique land
       Who said: Two vast and trunkless legs of code
       Stand in Redmond. Near them, on the sand,
       Half sunk, a shattered language lies, whose IDE,
       And DLLs, and ActiveX controls,
       Tell that its sculptor well those passions read
       Which drive market share, stamped on these lifeless things,
       The server that mocked them and the client that fed:
    
       And on the retail box these words appear:
       'My name is VISUAL BASIC, king of kings:
       Look on my works, ye Mighty, and despair!'
       Nothing beside remains. Round the decay
       Of that colossal wreck, boundless and bare
       The lone and level sands stretch far away.

------
tracker1
Cool to read.. though still somewhat disappointed that DLR languages were
pretty much left to die, and the JavaScript DLR implementation stagnated.

~~~
agnsaft
Bring back IronPython!

------
vorotato
F# is the best #

------
frik
.Net language strategy is to have no long term strategy. They just react to
the market, and don't care that much about anything else. VB6 was a great eco-
system, had most developers in the late 1990s yet they managed to completely
fuck it up. dotNet and it's VB.Net was a bad joke until 2003, and after years
of announcing and hot air it was incompatible, and the Wizard to convert was a
Lite version from a third party vendor. Many stayed VB6 and changed to the
web, or also also looked at Java alternative C#. But the RAD development is a
day of the past. Nowadays building a UI app is certainly more effort than in
VB6 days. Anyway, nowadays web apps and Android and iOS are in, WinPhone is
dead and desktop apps are out.

~~~
alkonaut
To be fair a lot of the VB6 ecosystem was showing its age in terms of text
encoding support etc. It is the Python2.7 of Visual Basic.

~~~
nmeofthestate
As a former VB6 programmer I'd say VB6 is the PHP of Visual Basic!

------
frou_dh
Is PowerShell not considered a first-class .NET language?

I thought it was on deck to take over default Windows shell/scripting status
from hellish Batch

~~~
simooooo
I wish we just had c# in a script form instead of powershell

~~~
nu5500
There is this: [http://scriptcs.net/](http://scriptcs.net/)

------
drivebyops
2017 type classes, 2018 Higher minded types ;)

Both going in at the same time would be better

~~~
louthy
You can almost do this in C# now [1]. It's ad-hoc polymorphism rather than
full on type-classes, but it does facilitate generic programming in a way that
I've not seen used in anger before.

For example, here's a definition of a super generic function that takes a
functor of string and maps it to a functor of int.

    
    
        public static FB ParseInts<Functor, FA, FB>(FA input)
            where Functor : struct, Functor<FA, FB, string, int> => 
            default(Functor).Map(input, Int32.Parse);
    

The secret to it working is the constraint that constrains Functor generic
argument to be a struct and a Functor<FA, FB, string, int>. The struct bit
means I can call default(Functor) and get a valid reference back (because
structs can't be null).

I can then call it with a List:

    
    
        var list = List("100", "50", "25");
    
        Lst<int> res1 = ParseInts<FLst<string, int>, Lst<string>, Lst<int>>(list);
    

Or an Option:

    
    
        Option<int> res2 = ParseInts<FOption<string, int>, Option<string>, Option<int>>(opt);
    

And it will happily map the bound values.

FLst and FOption are essentially the 'class instances'. Functor is the 'type
class', it's just a C# interface [2]:

    
    
        public interface Functor<FA, FB, A, B>
        {
            FB Map(FA ma, Func<A, B> f);
        }
    

The key thing is that 'this' won't be used, so the first argument is the value
to be mapped.

FLst looks like this [3]:

    
    
        public struct FLst<A, B> : Functor<Lst<A>, Lst<B>, A, B>
        {
            public Lst<B> Map(Lst<A> ma, Func<A, B> f) =>
                ma.Map(f);
        }
    

And FOption like so [4]:

    
    
        public struct FOption<A, B> : 
            Functor<Option<A>, Option<B>, A, B>,
            BiFunctor<Option<A>, Option<B>, Unit, A, B>
        {
            public Option<B> BiMap(Option<A> ma, Func<Unit, B> fa, Func<A, B> fb) =>
                ma.IsNone
                    ? fa == null
                        ? Option<B>.None
                        : fa(unit)
                    : fb == null
                        ? Option<B>.None
                        : fb(ma.Value);
    
            public Option<B> Map(Option<A> ma, Func<A, B> f) =>
                ma.IsSome && f != null
                    ? Optional(f(ma.Value))
                    : None;
        }
    

As you can probably tell, the amount of clutter from specifying generic type-
parameters that the compiler could (relatively) easily work out on its own, is
pretty annoying. Which limits it's usefulness somewhat. But if you want to
write truly generic code, it's doable (with some caveats of course. you'll
notice that the Functor type isn't quite as strict say the definition in
Haskell).

I'm currently updating my language-ext project to add type-classes [5] and
class-instances [6], in the hope that the C# team will take pity on me and
make this technique a language feature (it's been seriously turning my head
inside out trying to make it work with higher-order types like monads).

This is already being investigated by some Roslyn team members [7]. I figured
this feature was unlikely to move seriously in the near term without some
indication of real world need.

[1] [https://github.com/louthy/language-ext/blob/type-
classes/Lan...](https://github.com/louthy/language-ext/blob/type-
classes/LanguageExt.Tests/TypeClassFunctor.cs#L73)

[2] [https://github.com/louthy/language-ext/blob/type-
classes/Lan...](https://github.com/louthy/language-ext/blob/type-
classes/LanguageExt.Core/TypeClasses/Functor/Functor.cs)

[3] [https://github.com/louthy/language-ext/blob/type-
classes/Lan...](https://github.com/louthy/language-ext/blob/type-
classes/LanguageExt.Core/ClassInstances/Functor/FLst.cs)

[4] [https://github.com/louthy/language-ext/blob/type-
classes/Lan...](https://github.com/louthy/language-ext/blob/type-
classes/LanguageExt.Core/ClassInstances/Functor/FOption.cs)

[5] [https://github.com/louthy/language-ext/tree/type-
classes/Lan...](https://github.com/louthy/language-ext/tree/type-
classes/LanguageExt.Core/TypeClasses)

[6] [https://github.com/louthy/language-ext/tree/type-
classes/Lan...](https://github.com/louthy/language-ext/tree/type-
classes/LanguageExt.Core/ClassInstances)

[7]
[https://github.com/MattWindsor91/roslyn/blob/master/concepts...](https://github.com/MattWindsor91/roslyn/blob/master/concepts/docs/concepts.md)

------
alrz
VB for me was the gateway to the modern .NET programming. Back in school, I've
started with VB6 and moved to VB afterwards. The transition was somehow
seamless and made me understand the .NET ecosystem better. When I was learning
C# I had to first write my code in VB and then try to port it to C#. That was
just my way of learning things. It happen to be useful since now I'm fluent in
both when I need them.

------
omellet
I guess C++/CLI doesn't count as a .NET language? Shame it gets so little
attention, it's a fantastic interop language.

------
alkonaut
I have been trying to read planning docs, github issues etc and I still can't
find if my one pet feature is planned or requested for C#: proper exhaustive
pattern matching for records/tuples.

Tuples, records, etc are all find and dandy, but what I want is propoer safety
when adding a variant, otherwise they don't really help me reason about my
code.

~~~
AndrewDucker
It didn't make C# 7. Will hopefully be in C# 8:
[https://www.infoq.com/news/2016/05/csharp7-pattern-
matching-...](https://www.infoq.com/news/2016/05/csharp7-pattern-matching-
removed)

------
macca321
The best thing Microsoft could do for .NET is give LinqPad away with every
copy of Windows.

I'm hesitant to suggest they buy it out though.

~~~
svick
Not sure LinqPad is the right way to go.

What I would like to see is a dedicated REPL application (likely based on the
scripting dialect of C#) with IntelliSense and support for NuGet packages (if
you want to have those features in LinqPad, you have to pay).

Kind of similar to Xamarin Workbooks, but better, and without all the "it's
for documentation and inspecting applications" cruft.

~~~
gogocats
Not a dedicated REPL app, but there's an 'interactive window' for c# in VS
2015, it has IntelliSense (but no NuGet support, which might be added in the
future.) [https://github.com/dotnet/interactive-
window](https://github.com/dotnet/interactive-window)

------
arwhatever
I hope Microsoft continues to support VB.NET. I don't know what I'd do without
XML literals.

~~~
cm2187
As a heavy VB user, XML literals is the one thing I never found useful. For
serialisation, the XML serialiser is easier than doing things by hand.

------
amelius
I would recommend Microsoft to name their environments and languages such that
you can meaningfully search for them in Google. I could be wrong, but I can't
imagine searching for ".net" or "f#" gives any useful results.

~~~
iaskwhy
It seems perfectly fine:
[https://www.google.co.uk/#q=f%23](https://www.google.co.uk/#q=f%23)

------
velodrome
Microsoft has been trying to kill Visual Basic since 2005. It's like a zombie.
Credit to Microsoft for keeping customers and users of the language happy.

~~~
ZenoArrow
>"Microsoft has been trying to kill Visual Basic since 2005"

Where do you get that idea from?

Perhaps it's because of confusion over the name Visual Basic. Microsoft have
deprecated VB, but not VB.NET. The name 'Visual Basic' has been applied to
both, but they're not the same language. Microsoft's support for VB.NET is
stronger than F#, and second only to C#.

~~~
velodrome
I know the article was about VB.NET (successor) but I was referring to the
predecessor.

[http://www.tiobe.com/tiobe-index/](http://www.tiobe.com/tiobe-index/)

[https://web.archive.org/web/20141110003154/http://www.tiobe....](https://web.archive.org/web/20141110003154/http://www.tiobe.com/content/paperinfo/tpci)

VB actually GREW in popularity in the last two years. By the way, VB is
supported until 2024. That should be enough time to switch to VB.NET, right?
:)

~~~
dragonwriter
> VB actually GREW in popularity in the last two years.

Or people have been using the term "VB" to to refer to VB.NET as old-style VB
falls out of the general consciousness, distorting Tiobe's web search engine
based methodology for generating ratings.

------
Shalhoub
Pardon my confusion, but I thought that some time back Microsoft abandoned the
effort to write all their stuff in managed code under .NET ..

~~~
becarefulyo
Many of the built-in Windows 10 apps are written in C#.

~~~
kozak
So that now you have to wait until Calculator starts?

~~~
becarefulyo
Opens instantly for me.

------
snippet22
[http://www.tiobe.com/tiobe-index/](http://www.tiobe.com/tiobe-index/)

------
general_ai
I read this as "we don't really care about VB anymore, but we're contractually
obliged to say that we do".

------
beachbum8029
>Strategy for Visual Basic

Not >Killing it with fire

Very disappointing.

~~~
recursive
Why are you disappointed? VB is not exactly javascript, meaning it's easy to
avoid writing it if you try. And for that matter, what exactly is your
complaint about VB?

------
dbrigg

      > We will enable and encourage strong community participation in F# by continuing
      > to build the necessary infrastructure and tooling to complement community
      > contributions. We will make F# the best-tooled functional language on the
      > market, by improving the language and tooling experience, removing road blocks
      > for contributions, and addressing pain points to narrow the experience gap with
      > C# and VB. As new language features appear in C#, we will ensure that they also
      > interoperate well with F#. F# will continue to target platforms that are
      > important to its community.
    

Reading between the lines this says that further development of F# will be
dropped. They're handing it over to the community for plausible deniability.
Correct me if I'm wrong but it seems like a very sad day for functional
programmers.

~~~
MadsTorgersen
Hey, I didn't write anything between the lines! :-)

Don't worry: We're not "handing F# over to the community"! It always had a
strong community participation, and continues to. It's a fabulous
collaboration. This post is not an attempt to signal a change to our strategy
for F#, and if anything should be read as a commitment to F#.

We're currently integrating F# more deeply with Roslyn, which should lead to
an awesome bump in tooling quality.

~~~
dbrigg
Thank you and I apologize.

