
C# is the past, the present and the future - fekberg
http://blog.filipekberg.se/2013/01/11/c-is-the-past-the-present-and-the-future/
======
forgottenpaswrd
"I am a Software Engineer working with various techniques such as C#, WPF,
WCF, ASP.NET MVC, ASP.NET and much more"

"I spend most of my days working with the latest technologies from Microsoft."

"In the darkest alley-ways we still have the people not wanting to touch C#
with a pitch-fork because it’s behind Microsoft"

In my opinion he lacks enough neutrality to make that statements(how he know
MS tech is so great if he is totally ignorant of other options?).

Instead of telling people to learn only Microsoft tech he could take his own
advise and learn non Microsoft tech too. The world is much bigger than a
single company.

In my work as a software engineer I had to use what was good for my company,
not what was good for Microsoft, Apple, or any religion(GNU or whatever).

I had to use Java, C#, objective C, python, (and lisp and c and c++). We will
never be in the hands of a single company ever.

~~~
WayneDB
One problem with your statement is that C# is not only "Microsoft tech". C# is
an ECMA language for crying out loud.

~~~
taylodl
Microsoft used Ecma as a standards repository, not a standards body. Ecma
neither created nor endorsed C# - they received and recorded a standards
submission from Microsoft thus making C# "Microsoft tech."

Finally, neither C# 3.0, 4.0 or 5.0 have been submitted to Ecma. So we can
hardly refer to C# as an Ecma language for crying out loud! :)

~~~
WayneDB
I didn't say that ECMA created or endorsed C#. I said that it's an ECMA
standard because no matter how much posturing anyone wants to do, it is one.

Features of C# 3.0 and 4.0 have too been included in the ECMA standard. So
yes, we can definitely refer to C# as an ECMA language...for crying out loud.
The standard is not updated as often as Microsoft or Mono release a new
version of their runtime (ohnoes!), just like web standards when a browser
Mfr. comes out with a new feature.

------
jeswin
The article is very scarce on content. This could have been a tweet. Also,
saying "C# was here to stay from the beginning, we love it in the present and
we will use it more and more in the future." wouldn't convince many people.

In my view, the future of C# is hanging in the balance. Microsoft has lost
significant mind share, and I am not sure if Windows is a good platform
anymore to write new apps.

~~~
benologist
I have to agree, it occurred to me the other day that my almost one year old
daughter might never have a Windows computer, in the same sense that people 10
years younger than me simply never had an MS-DOS one, except this time
Microsoft didn't build the next platform.

~~~
WayneDB
Totally dude. Because C# _only_ runs on Windows. You can't use it to build
apps for the iPhone, Android, OS X or Linux at all. Nope.

~~~
benologist
Mono is an option for the current generation to learn one less language.
Outside of Windows it's not the default language for anything except Unity3d
so curious kids who grow up with tablets might not have much reason to learn
it.

~~~
WayneDB
So, nobody should learn a language unless it's the "default language" for a
platform? What is Python, Ruby or PHP the default language of? Should anybody
be learning Perl, Haskell or Objective-C in your opinion?

~~~
benologist
I'm not saying nobody _should_ but I bet a shitload more people go with
natively supported, which might be a better term than default.

And yeah this isn't at all specific to C#. Anything not natively supported
suffers - just ask Flash who in a handful of years have gone from a defacto
standard to a dinosaur.

~~~
gebe
I would say the experience is what matters. The user doesn't care what
technology the developer used. If you can make gorgeous, fluid and speedy
native apps with Mono and C# (which is very much possible) while at the same
time making it easier to do cross platform development and deployment then why
not.

------
merlish
This article has a great title. Would have been nice if there was a bit more
content to it; maybe we wouldn't have ended up with a bunch of hostile
comments with spelling mistakes.

So let's give it a go. An opinionated past, present, and future for C#:

The past:

.NET emerged seemingly in 2002/2003 with a feature set similar to Java. This
was pre-generics, and all code written in C# in this era is alien and involves
a bit of casting.

Microsoft released Visual Studio 2002, containing support for (at least)
Visual C#, VB.net, Visual C++ .NET (of course. let's blend two completely
different object systems. my actual favourite: Objective-C++ .NET), real C++,
and Visual J#, the successor to Visual J++ (which Sun had sued the crap out of
them for). Of course you're not jealous of the JVM, Microdollar! We believe
you.

C# did have structs at this point, distinct from classes, which are a pretty
cool feature. They're more lightweight than classes, and I believe are passed
by value rather than by reference like with classes.

Also, unsigned integer types. As a man who had to make a small machine
'emulator' in Java as part of a not incredibly well thought-out practical, I
appreciate not having to bend my mind around poking the sign bit to try and
get the real number I'm actually after.

And automatic unboxing and boxing of types was cool too. Int basically the
same as int. So they did have a few original thoughts.

Event handling also deserves a mention, so there we go.

I personally was coding in VB6 at this time, and viewed VB.net with a mixture
of bewilderment and contempt. So many keywords! Although the My.* namespace
looked really cool. Actually being able to find out and change things about
the current system, without being e.g. only allowed to change registry
settings in a VisualBasic area of the registry.

That was about the time that I was messing around with threads thanks to the
AddressOf operator, so really, a move was probably on the cards. (You had to
bind the Windows threading API yourself, and when you tried to pause in the
IDE it would only pause one thread, get confused, and crash.)

I eventually moved to VB.net (in the 2.0 era) and turned to treating C# with a
mixture of bewilderment and disgust. (Clearly, I'm a quick learner.)

~~~
merlish
The 2.0 era

Java and .NET got generics around about the same time, a few years later. Java
(sanely, to be honest) implemented generics via type erasure - so the compiler
does the type checking, and then emits code that has no type information for
generic containers - whereas the .NET team elected to break backwards
compatibility* and make the runtime understand generics.

I think Mono appeared around this time.

This is the time when .NET started to get going, to be honest. Never settle
for writing < 2.0 targetted code! Not that you can, unless you're running
Visual Studio pre-2005.

XNA ran 2.0, although Microsoft's bored of trying to get people who aren't
amateurs to use that now. Running my own code on the Xbox 360 was pretty cool
though. But they seriously needed to put a better garbage collector on that
thing. It was, er, rubbish.

* An annoying but possibly necessary decision. To this day, .NET 1.0/1.1 and 2.0+ apps require two separate runtimes to be installed, on Windows. Although Mono just deals with it, I think. Still, coming across the odd remaining 1.1 program can be a nasty surprise.

~~~
merlish
The present (kinda): 3.0/3.5

Man, why would anyone want any of this LINQ or closure stuff? I don't get it.
We already have event handlers, and for blocks can do anything LINQ can do
(that I'd use it for)!

It was about this time that I got into Haskell, somewhat out of necessity as
that's what our uni course starts teaching. I've only grown more fond of
Haskell since those days, mostly after learning a little OCaml/F# and seeing
how comparatively nasty ML syntax is. Yeuch.

VB.net kinda lagged implementation-wise for these features vs. C# - I guess I
wasn't the only person who moved from the former to the latter - but in C#
they were fairly glorious.

No more would we be teased about the relative verbosity of our language! Fine,
we still might go a bit long horizontally, but now we too can fit an amount of
functionality on one line sufficient to guarantee the confusion of the reader
and thus job security. Not that I have a job. Does job security keep you out
of a job if you don't have one? Hm.

LINQ uses method extensions (a hilarious but occasionally useful bit of the
language) to add new functions to all the collections types whenever LINQ is
imported. Mapping and 'aggregating' (folding) and what have you arrived in C#
3.0, with surprisingly nippy implementations, and a whole lot more came with
3.5/4.0 (I forget).

Cool stuff. Cooler with closures. With events we didn't have to worry about
writing inner Listener classes willy-nilly (insert comedy projectile vomiting
here), but you still had to define the type of the function you were writing
explicitly. Not so with closures. They're cool. I sometimes use them like
private inner functions, but I'm pretty sure that's my fault.

Something else most definitely worth mentioning that came around here that is
undoubtedly a good and cool thing was type inference, or the super magic 'var'
keyword. (Like the C++ auto keyword, THAT CAME AFTERWARDS (possibly). We're
inventing! Yay!)

Out with the List<string> stringList = new List<string>()! In with the var sl
= new List<string>()! Glorious.

While I'm going long here, I need to also mention automatic property
implementations.

So we don't have getWhatever and setWhatever functions in C# - (though we do
agree with our Java brethren that generally exposed fields Are A Bad Thing) -
we have: public whatever { get { return _whatever; } private set { _whatever =
value; } }.

But in 3.0, you can do e.g. public whatever { get; private set; } and the
boilerplate is written for you. If you ever want to swap them out with some
code that actually does something at a point after that, you can then go ahead
and do that. Awesome stuff. Java coders love this when they learn about it.

I think Mono also came of age here and stopped sucking. A new generational
garbage collector (sgen), far greater API support, and the demands of game
developers embedding the runtime left, right and center undoubtedly helped.
(Mono runs on Windows and consoles, too, you know!)

Their System.Drawing implementation is still a bit crappy, though. I've had to
do some weird things to alpha channels and what have you.

~~~
merlish
The future:

.NET 4.0 gave unto us the second revision of the F# language, and the Async
and Await keywords. These are extremely cool, and I have had a great deal of
fun writing seemingly-synchronous code (e.g. a character generation module for
a MUD) that turns out to be asynchronous with the right words in the right
places. Marvelous, great job, etc.

F# didn't begin existing at this point, but it basically did for me. F# is
open source as heck, so it has a bit of the cool factor, and it really is just
another take on OCaml. Unfortunately F# 'objects' (things, I mean) aren't real
.NET objects, but you can explicitly write real .NET objects within the
language with only slightly more verbose syntax and going the other way is
really easy.

F# is a lot of fun and a real functional language. If you haven't tried it,
you really should. Async and await are amazing here too.

Also gave us the .NET Framework 4 vs. .NET Framework 4 Client Profile as
distinct framework targets. Clearly the latter is a cut-down version of the
former, except that there's almost no difference in the available
functionality, and the downloads for both runtimes are almost the same. Hm.
Mono ignores the distinction completely, and I think we should too.

Whatever. Clearly C# is a labor of love, and we are going to get all the
features we can ever pretend to understand over the coming years. I look
forward to the eventual relaxing of having to put startup code in void main
instead of just loose in the file (maybe), the IDE having more understanding
of code (even if .NET intellisense in VS blows the C++ version out of the
water and, indeed, at least three levels of atmosphere), and (optimistically)
a more coherent F#.

.NET 4.0/4.5 has a bunch of features I can't even remember right now, and I
look forward to learning more about the language, even if Littlecurrency
politics seem to currently neglect .NET for C++ and Javascript in Metro apps a
bit. (WinRT is a really cool framework though.) C'mon, only C++ apps allowed
to use Direct3D? What year is this?

I'm still going to keep using C#, and I'm not the only one. (I use other
languages too. Doesn't everyone? Go rules, Ruby has some very exciting ideas,
and I wrote a node.js app the other day that to my surprise wasn't actually a
piece of shit. So that's nice.)

I think that 'a slightly better Java than Java' is an idea that will prove
promising for years to come.

A little about Mono:

Mono is a great platform, for what it's worth. With their new garbage
collector (that can be tuned!), almost complete* support for the latest .NET
4.5 feature set, and their own additional features (tasklets and SIMD
instructions, a REPL, and Compiler as a Service, anyone?) on top, I think it's
pretty cool, and you might, too.

At the risk of preemptively lowering the tone - the current discussion here
isn't that bad - the current best defense of Mono is an old Jo Shields rant at
<http://apebox.org/wordpress/rants/124/>, though its tone is a little
inflammatory at the start.

To summarize: Mono is independent from Microsoft, covered by the Open
Invention Network re. patents, is a free implementation of an international
standard by a convicted monopolist (a la the entire GNU system for UNIX) and
is actually quite awesome in its own right. It's not just a compatibility
framework. It isn't 100% compatible with the .NET Framework, and it doesn't
need to be.

* Mono doesn't support WPF.

------
egeozcan
I like C# and I also think that it will keep evolving. But statements like "C#
has adapted to the needs of the community over these 13 years or so very well"
without explaining how makes this article sound too marketing-oriented.

------
guard-of-terra
I would like to try it out but I'm not on Windows obviously, and I won't work
to become a second class citizen ("What do you use? Mono? That's not
supported").

Also, most of tooling seems to be proprietary, Windows-only too.

So I'd stick to JVM.

~~~
fekberg
I'd suggest you give Mono and MonoDevelop (<http://monodevelop.com/>) a try!
It's really good and at least most of the web stuff that I've developed have
just worked out of the box on Linux (Apache + Mono).

~~~
guard-of-terra
I don't want to be a second class citizen.

I don't want to be a second class citizen ever. I don't want to be a second
class citizen. I don't want to be a second class citizen ever.

"Really good" is so much different from "The Most Awesome Edition" you get
with languages like Java or Ruby.

I can tinker with a "Really good" tech on home projects all right (except I
prefer Clojure), but not in the workplace.

~~~
jinushaun
There are real companies out there making real money off Mono. So it's not a
toy reserved for weekend tinkering. Enough companies trust Mono to use it in
production.

~~~
guard-of-terra
I'm happy for them, but I'm not going to risk it. The reward is nice but not
nearly worth the risk.

When adopting Java, you can trust it will just work, but with Mono you have to
_bet_ it's going to work, you're not going to run into compatibility problems
and tooling will be adequate.

~~~
jackalope
Java comes with its own problems, especially in enterprise environments where
you might be pinned to a single version. There are plenty of insecure JVMs out
there that can't be upgraded on both servers and clients, mainly to ensure
compatibility or meet support requirements.

~~~
guard-of-terra
I don't see how it is relevant WRT considering a language/platform for a new
project. You're talking about legacy stuff. I don't see how this can't happen
to project in any language (PHP? Ruby? Perl? C#?)

------
jinushaun
He clearly works for MS and probably on the team that works on C#, which is
why I find it odd that he touts Mono as a feature. If MS was serious about
.NET everywhere, they'd sponsor Mono/Xamarin, or offer native .NET support for
OSX and Linux instead of using the Mono community's hard work to toot their
own horn.

C# is a great language and has evolved beautifully, but many people will still
continue to avoid it because it's owned by MS and stuck on Windows (without
the help of Mono). The next Google, Facebook or Twitter won't be written with
C#.

~~~
teh_klev
He isn't MSFT staff, read his "About the Author" page, he works for a Swedish
company. Also he's a MS MVP, you can't be a Microsoft MVP and work for
Microsoft at the same time.

~~~
jinushaun
You're right. His use of "we" had me confused.

------
j_s
From my limited perspective, C# hasn't changed much apart from syntactic sugar
(less typing!) since generics were added in v2.0. This is similar to all the
stuff Microsoft throws into their C++ compiler to make COM more user-friendly.

Most of the additions have been to the CLR, where Microsoft has earned a
reputation for changing behavior in the 'green' bits (meaning: supposedly
unmodified) when updates are installed. Also, Windows 8 brings the new WinRT;
it's impossible to know how long either runtime will be 'the one true way'
(see Silverlight).

It's hard to get behind a software development tech created by a company that
makes its money selling new versions of operating systems and development
tools (the cool stuff always requiring the latest versions, of course!).
Microsoft is always moving the cheese.

------
cageface
C# is a great language and Ximian has been doing brilliant work on Mono but
I'm actually starting to wonder about the long-term prospects of Microsoft.
Without a significant corporate sponsor I'm just not sure it has the momentum
to endure.

~~~
rjd
Most of the Microsofts revenue comes from server side stuff anyway, 60% from
memory(?), it'll be a good 5 years at least before that market dents. I don't
think you'll see c# going away anytime soon.

EDIT : couldn't find 2012 but heres 2011
[http://punchcut.com/sites/punchcut.com/files/win8_1-8_eb-
msf...](http://punchcut.com/sites/punchcut.com/files/win8_1-8_eb-msft-
revenue-q42011.jpeg) business + server looks around 60% which I guess is where
my figure comes from

~~~
smegel
I thought office was the cash cow...lot more desktops out there than (Windows)
servers.

~~~
josteink
But lots of those desktops comes with cheap, sponsered OEM-licenses of Windows
and Office. You don't get OEM rebates for your MS server-park.

~~~
smegel
Not the ones in corporations, they don't get oem anything. MS can, and does,
extort practically whatever it wants from big business who basically are
incapable of realizing alternatives to office/windows.

------
7D8
DO NOT mention Windows in a good way on HackerNews, its just taboo around
here. (sarcasm)

------
damian2000
I love C# as much as any MS fanboy would, but when people like Charles Petzold
start abandoning C# and .NET for native C++ -
[http://blogs.msdn.com/b/msdnmagazine/archive/2013/01/08/1038...](http://blogs.msdn.com/b/msdnmagazine/archive/2013/01/08/10383228.aspx)
\- to get more speed out of Windows 8 apps, then you have to start thinking
maybe Microsoft is at least pushing C#/.NET out of the limelight - its not the
be all and end all it used to be.

~~~
dromidas
Not everything needs native C++ performance. I use C# all the time on things
that need easy maintainability and to be as secure as I can reasonably make
it.

~~~
damian2000
Totally agreed ... horses for courses etc. I also use C# the majority of the
time ... but it seems like it will now be sharing the stage with C++ and
possibly HTML/JS in terms of the recommended languages by MS.

------
mahmoudhossam
Can you please rewrite this so it doesn't look like an ad for Microsoft?

~~~
yellow2blue
He's a junior MVP, of course it has to look like an ad :)

------
thebluesky
> _C# was here to stay from the beginning, we love it in the present and we
> will use it more and more in the future_.

This article would have received a bit more respect if it had been a bit more
subtle about the C# cheerleading.

------
camus
C# and .NET were designed to sell Microsoft Windows Servers, C# = Microsoft
and any side project like Mono can be shut down any time. Microsoft did not
become what it is by embracing open and free technologies unless it was to
"extend and extinguish them", if you dont pay for a product one way or another
there is no reason for Microsoft to support that product. C# is a good
language but definetly not the future.

~~~
numo16
Microsoft has been making some decent moves into open and free as of late. The
biggest thing lately, that I can think of, was their open sourcing of the
entire asp.net stack:

<http://aspnet.codeplex.com/>

<http://aspnetwebstack.codeplex.com/>

