[go-nuts] .net core vs go

You’re going to get a lot of useful responses to this Q, but in addition to everything else people say, I’d suggest a little meditation on the following questions:

(1) Why - exactly and concretely - do you say "I would like to use Go"? (You answered this at least partially in your post. Is there anything else, perhaps including non-technical factors?)

(2) Why - exactly and concretely - do you suspect these reasons would not persuade your boss?

(3) From the point of view of your organization’s goals, are the reasons in (2) legitimate, or ill-considered/short-sighted?
     (a) Legitimate could be eg technical virtues of Go don’t outweigh other business-centered factors.
     (b) Ill-considered could be eg boss has her/his own favorite language.
     (c) Short-sighted could be eg giving transition costs too much weight compared to long-term benefits.

(4) If, on objective reflection, the answer to (3) is "largely legitimate", then this is an opportunity for your own self-mentoring and personal growth.

(5) If the answer to (3) is "largely ill-considered/short-sighted", then how - exactly and concretely - did your self-reflection convince you of this? You’ll find in there some of the arguments you’re looking for.

Lather-rinse-repeat after each time you talk to your boss about this, in light of what she/he (and you) actually had to say.

Please understand that I'm not out to slant you one way or the other re the answer to (3). Both happen every day, and getting good at distinguishing one from the other is a great skill to develop.

Good luck,
Mike


From: <golang-nuts@googlegroups.com> on behalf of Luca Looz <luca.looz92@gmail.com>
Date: Monday, May 16, 2016 at 06:37
To: golang-nuts <golang-nuts@googlegroups.com>
Subject: [go-nuts] .net core vs go

I'm a big fan of Go and i have used it for some side projects. I like its performance, built-in concurrency, easy cross platform builds and the concept of being practical and productive.
My company it's currently .net based, we develop all backends (scrapers, rest api, web sites etc) in vb.net and c#.
We want to switch to something crossplatform and stick with it for all new projects.
My boss discovered Go and he likes it too but i know for certain that .NET core (currently in RC) it's an obvious choice because we don't need to learn a completely different language and development environment.
I would like to use Go but i don't know which arguments can i use to persuade by boss, any hint?

(1) Yes there are non-technical factors too. I just want to ditch .net and
use something completely new and non microsoft related. I also want to
switch from windows server to linux but this with .net core will be
possible too. Currently we mainly develop ios and android apps and the
company is splitted in mac and pc users (i'm using a mac for android
development and use a windows VM to do some .net stuff when needed)

(2) I suspect it because all of my backend coworkers have only a .net
knowledge and a little of html/css/javascript and i'm the only one that
have done something in Go

(3) I think that my boss has a legitimate reason for choosing .net core
because it offers cross platform development (the main thing that we are
seeking) and we can be productive quickly. Even if .net core is in RC we
can continue to develop with the classic .net and switch to core gradually.
We are in a phase of "changing" and we are starting to do web apps with
angular etc, my boss is also considering nodejs because we can use a single
language both server and client side (web)

My will to choose golang maybe it's selfish but i think that in long term
Go is a better choice performance wise, license costs (maybe by adopting go
we will be more willing to use linux and open software) but also because
switching to something new (and better for my point of view) can be an
opportunity to loose bad habits in development

Il giorno lunedì 16 maggio 2016 16:52:23 UTC+2, Mike Orr ha scritto:

Keep in mind that .NET core is still not ready for production, even in RC2
status. The tools are incomplete. The runtime is not optimized. RyuJIT
still needs work.
You'll have to get used to new CLI tools, some based on node.js (because
not everything integrates with MSBuild yet), work in VSCode or another
editor (Visual Studio does not integrate with .NET core yet).

Go is production ready right now and I've been using it to develop in
Windows, then cross-compile (very easy) and deploy to QA/demo/production in
Debian. It also requires switching from Visual Studio IDE to other tools
but that is expected.
I use it to replace PHP and Python mostly, not .NET. Some areas you may
find lacking in availability of 3rd party libraries and starter kits.

If you absolutely have to deliver a solid Linux-based web project in 3 - 6
months from now, Go might do it for you while .NET core is unlikely to. If
the project deliver date is a year away, .NET core will probably work fine
(still a risk though).

You can gradually introduce Go in small projects like RESTful services,
command line tools, etc. and see if others like and accept it without
committing full-scale.

IMHO you must consider nodeJs.

Il giorno lunedì 16 maggio 2016 15:37:20 UTC+2, Luca Looz ha scritto:

Learning is part of being an engineer and go is easy to learn. It looks
scary and awkward at first, but once you dive in you realize it's fast to
build things and fast to learn and the community I think it's pretty mature
atm with lots of tools evolving.

<trollmode>
Haxe ( http://haxe.org ) compiles both to C# and javascript. One should add Go backend to Haxe.
</trollmode>

Hi,

since i am pretty much you are i can give my 2 cents.
go has some features that make the language really attractive like
concurrency, cross-compile, good standard library, easy to learn etc etc.
the problem for me with go is that the tooling is not that good. Keep in
mind that when writing c# you are using Visual Studio which is one of the
best IDE.
Keeping this in mind i feel that i am more productive and can do more stuff
when using Visual Studio. Debugging is a breeze, visualization is too,
profiling is crazy etc etc.
Some language features like generics, linq do make a great difference when
working!

Since the announcement of .net core the benefits of golang are not that
strong anymore since .net core does cross compile, concurrency is really
nice (async-await) and they get channels too(see CoreFX Labs), there will
be a way to generate on native binary with .net native (this i have to
check out better), kestrel (the web server based on libuv) does shows very
nice benchmarks and will be posted at some point
to https://www.techempower.com/benchmarks/, F# will be available for .net
core too, MVC is there and off course you can be right away productive with
your previous knowledge.

I will be still expand my skills in golang but .net core is a really good
option. btw release date of asp.net core 1 is end of june 2016. so you can
start using it already.
hope this helps

This comment makes me think you're planning a step too far. From the
description of what your company is doing, you probably have the
opportunity to try something new for a specific small project. Pick a
project that would benefit from Go, and make a case to your boss that you
should try just that project in Go, and learn from it whether or not Go is
a fit for your company. In general, it is a terrible idea to re-implement
existing code just to move to a new language. This trial project can play
out in three ways:

a) It works brilliantly.
b) It works terribly.
c) It is inconclusive.

If you land in category (c), then you've probably got your answer - stick
with C#. That's where your company's expertise lies, and the biggest
expense your company probably pays in developing these projects is the cost
of your developers' time. Obviously, don't sabotage your experiment, either
by picking only the best people for this team, or only the worst - try to
make your team and its experience align with the rest of your company.

We are blessed / cursed with too many options for cross platform
development. Java, Javascript, C#, Swift, Go, Rust, C++, Haskell, Clojure,
Python, and Ruby all seem viable based on your description. I'm guessing
you've discarded Python & Ruby because of performance concerns. Personally,
I'd discard Java, because the huge changes coming with Java 9 might be
seriously disruptive, Oracle is still causing legal troubles around Java,
and Oracle has a very poor history of engaging with open source (and
doesn't seem to be changing). C++ is probably too complex, and may be
difficult to find great developers. Haskell & Clojure also probably suffer
from difficulty hiring - unless you have specific libraries or features
that align well with those languages. That leaves you with C#, Swift, Go,
Javascript, and Rust.

C#, Swift, and Go all have a single major corporate sponsor. This is both a
strength and a weakness. On the strength side, it means *great* support for
the really hard parts of making a great language - performance, better
faster memory management, documentation, and obscure bugs, just to name a
few. Of the three, however, Google's future isn't tied to developer
engagement with the language. Which ironically, makes it a stabler choice,
because it isn't as likely to change just to chase the latest programming
fad. Community outside of Google also seems quite robust. Microsoft does
not have a long history with positive engagement with Linux, so that
deserves some skepticism (although, to the company's credit, it has changed
dramatically over the past few years), and has a long history of making
languages not quite conform to standards. Microsoft also has a very long
history of trying to lock you in via many subtle and overt means. Makes me
skeptical. Apple has a long history of changing Objective-C to fit the
latest needs of their OSes, and Swift has already moved to a 2.0 version,
so they seem to be keeping to this trend, and thus I wouldn't recommend
Swift (yet).

So at least for the corporate-backed languages, looking from the business
perspective, the long-term viability of languages based on the historical
record of changes seems to favor Go. Google looks like it will not push
backwards incompatible changes into the language.

The other languages to consider, then: Javascript & Rust. I don't know
anything of substance about Rust. As for Javascript, I know teams that have
been successful precisely because they can have developers move from front
end to back-end and vice-versa. The Javascript community is driven to
continued massive improvement in order to improve the overall experience of
the web (driven by corporate interests, and robust competition from open
source).

Based on just business considerations, my take: Javascript and Go.

From a technical perspective, it depends on what you're trying to do.
Javascript / NodeJS developers rave about how everything is asynchronous.
Unfortunately, that very asynchronous nature means that you have to turn
your code inside out, waiting for events. My personal preference is to
favor linear thinking - our brains seem to be better at it. Which means
that Go's model of goroutines and channels works better for larger scales.
My experience also suggests that large code bases due much better with
static typing, not dynamic typing. Again, benefit to Go.

One final thought - conceptually, Go is a pretty straightforward language.
Which I makes it easier to pick up and read someone else's code. For
long-term support of a code-base, this is a huge win.

Overall, though, I'd suggest to both you and your manager, that in fact,
the future lies in being multi-lingual. You need Javascript for the front
end, but might have better success with something else on the back-end. For
mobile devices you may still need to use a "native" language such as Swift
or Objective-C. You almost certainly still need SQL. Right there, that's at
least four languages. The robust competition around cross platform
languages means that we're going to experience somewhere between 5-15 years
of these languages competing to win the space. Impossible to guess what
will "win" on the far side of that time.

Eric.

There is no debate here, .net comes with 15 years of libraries with battery
included . If you're goal is to develop a complex web application with
complex business logic, form logic,validation logic, view logic, ORMs and
what not, .net core will be a better fit. Go is good for plumbing and
writing server infrastructure components that doesn't need ORMs, complex
validation schemes and what not. Just have a look at MVC6 then look at Go
ecosystem when it comes to http frameworks. There is no equivalent. MVC6 is
a sweet spot between JSF and Rails , it embraces dependency injection ,
Async I/O with Kestrel and you wont need any library but the core framework
for most of your work. Hundreds of people get paid to work on asp.net so it
is no surprise it is a complete framework with good integration with
Windows software if you are in the enterprise space.

Fortunately, Go isn't a tool that requires a lot of investment when it
comes to learning or deployment so it can remain in your toolbelt when
needed, instead of using a scripting language for instance.

Le lundi 16 mai 2016 15:37:20 UTC+2, Luca Looz a écrit :

He mentions that they have a bunch of Web scrappers, this kind of task is
heavily concurrent, something that .net is not know for, but golang is. We
are a php house, but we are switching to go for this one reason, our new
internal stack wil be based on php frontend, golang based microservices
layers, and mysql, elasticsearch and mongo based data stores.

We also run Windows and Linux servers, we are continually having problems
with our windows systems stalling becuase the predominate pattern for
services there is to build a "windows service", which suffers from issues
with leakage of resources, deadlocks etc.

The predominate pattern on linux for services that don't have a listener,
is to use cron driven tasks that execute a fixed amount of work and then
die, freeing up all resources except persistent ones like disk space. This
makes them very much more reliable. Golang has good support for building
listeners too.

Dear Tim,

We are a .Net house and we are running "windows services" for months
without having any problem. Sql Server, which is a very robust RDBMS, is a
windows service and runs rock solid for years. So the issues you mentioned
are mainly your own code issues.

Windows has a feature called Task Scheduler where you can schedule anything
to run on a schedule if that is what you want.

The claim that .Net is not heavily concurrent is not true either. You can
use TPL (Task Parallel Library) and run a really solid and performant
concurrent programming model with ease.
This will scale very nicely with the cores of your machine. Especially when
using Parallel.For which does some optimizations.

Long story short. Please try to be correct on your claims since you are
sounding like you don't know windows and .net that much. no harm intended.

Kind regards

Thanks for introducing this topic, its a good read.

Its a proverbial can of worms though, as any "Language X vs Language Y"
sort of question is likely to be. The only thing worse that advice on
language & platform wars is career advice .... so Im going to take the
extreme liberty of doing both :)


.Net Core vs Go ???

Its the same as asking about taking a trip into town ... should I catch the
bus, or ride my bike ? Both will get you into town at around the same
time, but from there on the differences are innumerable. Personally, Id
take the freedom of the bike, and risk getting wet or run over anyday.

Should we chop up some fresh ingredients and cook a homemade meal, or stick
a frozen pizza in the microwave ? Both options produce a meal. Personally,
Id rather know what Im eating.


Convince the Boss ??

I would strongly advise against any attempts to persuade your Boss, let
alone adjust the corporate culture that you are currently in. Its do-able,
but its too easy for a developer to underestimate the amount of energy
needed to pull this off, and besides, it rarely ends well, and cuts deeply
into your coding time. You are going to be one against many, and its going
to be a long and sometimes pointless battle. Since there are quite a few
people in that company who are invested in MS skillsets, anything different
is going to be treated as a threat by many of them. You will make new
enemies for sure. There are just too many things that you simply don't have
direct control or authority over in that environment.

Nothing stopping you from investing your own time outside of work in your
own projects though, and having full control over the outcome. Win or Fail
... it will make you a far better developer all round, and set you up much
better for your next project.

Go is low volume but hot in the job market at the moment. I am seeing some
interesting positions becoming available, and the job descriptions tick all
the right boxes. "The Market", if you like, appears to be putting a very
high value on Go developers. (ie - they are high calibre positions that
carry a good deal of respect and creative freedom ... and that is exactly
what you are looking for).

Whatever you do though, don't follow MY advice, unless you really want to
walk in my shoes, and experience the same ups and downs that I have chosen.
Same goes with any other advice. But while we are at it, if I was in the
same boat as you, I would choose to start working on my next move at this
point. Do a great job where you are, but forget about trying to change
them. Get really good at what you enjoy doing, make your experiments and
mistakes in your own time, and cultivate your next move to a company that
is in more in line with your own goals and view of the future.

Trust your gut, walk your talk, and don't be afraid of failing.

Start looking around I reckon.

If your current Boss is any good, then take him with you too :)

Thank you all for your interest in this, in the end it is more a business
decision than a bare ".net core vs go" comparation.
I have talked with my boss and i think that we will have a long-term plan
like this:

    1. Keep working with classic .net
    2. Acquire knowledge about open rdbms (mysql/mariadb,postgres etc) and
    replace sql server
    3. Meanwhile for small "isolated" projects and if the team agrees use
    golang and linux servers
    4. As soon as .net core matures gradually switch to it and to linux
    servers where possible
    5. Draw conclusions about where we got


Il giorno lunedì 16 maggio 2016 15:37:20 UTC+2, Luca Looz ha scritto: