Why Startups Could Use .NET, But Don’t
piehead.com
piehead.com
When I read this, my first reaction was to think, "yeah, but how often do you really do any kernel hacking?" But actually, I've been on teams that have done all of the following:
* run a patched version of PHP in production
* run a patched version of the Squeak VM in production
* run a custom-built Apache in production (no patches, but highly-tuned build configuration)
* run a patched version of the OS X automounter daemon for office infrastructure
Ok, it's not the kernel, but it's fixing problems and implementing features at the right place in the stack instead of working around them and waiting for a vendor to ship a new version. I'm not the right guy to do kernel-hacking, but I know that those people are out there and I can hire them to do what I need, if it should come to that.
So, sure, it's cultural. But part of that culture involves not being enthused by the idea of waiting for Microsoft or IBM or Oracle to fix a problem that's affecting my customers now.
Sure, that's what caused it.
Purchasing/licensing software is always a hassle. Even aside from the monetary cost, you need to decide which to buy, go through the purchase process, and sometimes you also have some activation hassle.
With open source software, you just download it and use it. If you decide to change to another version of the software or different software entirely, you just do that.
Startups are hard, removing anything that takes time or effort is a good thing.
But even with this, cost is still an issue. Yes, salaries are the biggest cost, but in a startup, you might be working for yourself, so no salaries are being paid. Having to shell out any money at all becomes something you avoid. (Yes, there are Microsoft programs to give you Microsoft software at very low prices. But the procedure for those programs is always more complicated than "download and run".)
This. Navigating MS licensing is an absolute headache inducing time vampire for smaller organizations.
Navigating MS licensing is the software equivalent of navigating the US tax code. Why would you willfully subject yourself to that when you could be getting things done?
1. While building software architecture and designing features day by day, no startup wants to consider licensing schemes of proprietary software as a factor.
2. No startup wants to consider bullshit sales-minded product versions (professional, enterprise...)
3. No startup wants the over-paid software sales people to chase their profits tomorrow by inventing licensing schemes per user, cpu, expires in x years etc.
Startups want flexibility and freedom while innovating. Open Source (for example, Linux, MySQL Server, Rails/Ruby) give all those freedoms.
And innovation requires freedom while thinking.
Edit: I am a former MS solutions architect/programmer who built large web applications using .Net, Commerce Server, Sharepoint and various MS products between 2001-2005. Since 2006 I build exclusively using open source alternatives; and God, what a relief.
I think this is the main point here. Especially in startups, parts get written and rewritten many times. Ruby backend too slow? Rewrite in Scala/Java/C++. Relational database doesn't quite fit? Extract a part of it into MongoDB etc. Besides, the community behind all these tools is healthy and responsive. Example: we had a stupid problem with Redis, asked on the forum and the guy who wrote Redis responded in matter of hours. Hell, maybe he even reads these words right now (hi!).
Call it cultural, call it technological, but there is quite a difference between two worlds.
Let's assume you are out of BizSpark, which gives you what you need for free. Now you have a list of licenses to acquire.
What I did last was to call CDW, they put me in touch with their MS licensing guy which actually looks at this stuff full time, he took our info down and simplified our options and it was a quick decision after that.
This is just superfluous complaining, IMO. It's not that hard. And activation was not a big deal with volume licensing. Plus activation issues are a one-time things.
Which is the point of the article: It's much more culture than actual tangible differences/superiority.
The BizSpark stuff is the worst (read it carefully: what you can do with it is VERY limited compared with what the marketing materials imply you can use it for).
Anyway, I still don't see licensing as that difficult. Maybe just a difference of opinions, which is ok.
In the grand scheme of things (IMO again) licensing costs are infinitesimally small compared to, say, choosing the wrong system architect, or not taking into account scale requirements, hiring an idiot programmer, etc.
Sounds like you took the path of least resistance with Microsoft licensing, and may have paid significantly more for the privilege.
Maybe that was the right business decision for you, but its hardly a refutation of people who decide that open source licensing is a lot less hassle: No BizSpark application to fill-out, no fear of expensive licensing gotchas once they outgrow BizSpark.
As long as you do not betray the long-term goal, the path of least resistance is absolutely the one to take. Always.
Keeping on-topic: To a Windows-experienced team, the path of least resistance is to stay on Windows, even with its baggage. Same can be said for every other platform: Ruby guys, stay with Ruby all things being equal, and so on.
PHP guy tasked with building a high-performance socket server? The path of least resistance given the goal is probably to switch to another platform for this project.
EDIT: About MS maximizing profit: By definition, that's what a business does. Which business does not maximize profits?
That wasn't my point. My point is that microsoft maximizes profits by making licensing so complicated that a significant percentage of their customer base over-pay for licensing rather than take the risk of being under-licensed.
Since you took the path of least resistance, you may have overpaid for licensing. If your goal, as a business, is to maximize profits, well, then, you've worked against your long-term goal.
It may be that the cost of overpaying microsoft for licenses was cheaper than the opportunity cost of figuring out how to pay less for licenses.
Which brings me back to my main point, it is no disgrace, as an engineer, to decide that Microsoft licensing is a problem better avoided.
Using open-source tools to save a few dollars is a sure sign of either incompetence or inexperience, and a soon-to-fail project.
For a small startup, the cost is the time it takes to try and understand your licencing agreements - it wastes a lot of time...
What exactly have you built in .NET that is greater?
And the other 40% of the web ... well, it's cheap and has low barriers to entry. That does not mean it's great.
For one, PHP (any language actually) is it's syntax and libs.
So, that they "threw away the rest" is not an argument against PHP. People also run Rails on different rubies (JRuby/Rubinious/Ruby EE etc), so what?
And they "threw" those for performance reasons, not for some better, purer language. If they had enough problems with PHPs performance to write a C++ compiler for it, you think they would have faired better if they started with something like Rails?
Second, yeah, with multi billions revenue and nearly a bln users, yeah, I'd say it turned out pretty well for them. Proves that you can get pro --it doesn't get any more pro than FB in the web business-- without using expensive tools or the language du jour.
"""And the other 40% of the web ... well, it's cheap and has low barriers to entry. That does not mean it's great."""
There are Drupal/Wordpress sites that are among the best of the world...
I don't know what you mean by "cheap" in this context. Is whitehouse.gov cheap?
If you want to attribute the lions share of success of Facebook to PHP, rather than the social effect and being in the right time in the right place, or other work put into it, that's fine with me. But I'll still disagree.
> they "threw away the rest" is not an argument against PHP.
If replacing the backend (compiler, libs, etc) because it's so buggy and does not scale at all, is not an argument, than nothing will be ... and I'm going to stop here and let this die.
Not for a pre-seed startup. In that common situation, software licensing costs can be by far the biggest cost you have.
> Using open-source tools to save a few dollars is a sure sign of incompetence, inexperience, and a soon-to-fail project.
Saving a few dollars in return for tools that are on average of similar quality - sometimes better, sometimes worse - is in no way like what you just described.
In that situation, it's almost free-of-charge from Microsoft with their BizSpark (and similar) programs.
For a startup, messing with that is a distraction when there are equal-quality tools available by simple download.
> when there are equal-quality tools available by simple download
I suppose the keyword is when or if. I which case that becomes true.
Are we reading the same thread? Pretty much everyone agrees that MS licensing is convoluted and bothersome.
>> when there are equal-quality tools available by simple download
> I suppose the keyword is when or if. I which case that becomes true.
Good software can be proprietary or open source. These days, neither is better than the other overall. You need to make a specific choice in each case.
1) You keep using these words: rounding error. I don't think they mean what you think it means.
There are startups, and successful ones, that have the tiniest of budgets. People literally survive on ramen and faith. For those kind of companies, the costs are not a rounding error -- and there's often no salary or minimal salary paid to the 3-7 man team initially, while they still have to have some servers and development tools.
2) It's not just the licensing costs. Even for a team with tons of cash that makes them negligible, depending on a stack fully determined by some other company is not a good idea. Startups rewrite stuff all the time, use different technologies when they find out the old doesn't fit nicely enough, etc. You can't be dragged down because you have written all your code in a proprietary stack for each and every component...
I've used those words once.
> You can't be dragged down because you have written all your code in a proprietary stack for each and every component...
No. But you can be dragged down with buggy, poorly engineered, and badly integrated tools.
> No. But you can be dragged down with buggy, poorly engineered, and badly integrated tools.
And that has nothing to do with whether they are proprietary or open source.
I really, really like .NET, ASP.NET MVC, and C#. And I even have grown to appreciate IIS 7 and SQL Server. But if I left this company and did a start-up project all over again, there is no way in hell I'd pick .NET for the kinds of things I find interesting.
Here's the rub: whenever we're doing something in Kiln that Microsoft anticipated, the environment is among the best I could possibly imagine. There is something they already wrote that works, makes sense, runs quickly, and is flexible without taking you into IoC debugging hell. If you want to take on something that is not using cutting-edge web technologies (i.e., you're not using WebSockets, or working with big file uploads, or doing strange routing, or what have you), you're probably in great shape.
But when we do something that Microsoft did not anticipate, it's nothing but pain. Take allowing you to push Mercurial requests through HTTP: we still get into fights with IIS, two years down the line, because we keep encountering limits that Microsoft set that make absolutely no sense if you're not a vanilla CRUD app, and whose removal is poorly documented. For example, IIS limits the amount of headers you can have. This setting isn't actually even set in IIS proper; it's set in the generic HTTP layer of Windows, which can only be altered with a full-blown machine reboot. So when one of our customers dutifully managed to craft a Mercurial request that was over 8k or whatever the limit was, we had to go reboot every last fricking production web server during our peak load time so that they could actually get their changesets through.
Or take streaming requests: ASP.NET is so insanely aggressive about not allowing you to stream in requests that we had to replace swaths the official framework with our home-grown solutions before ASP.NET finally relented and quit trying to suck multi-gigabyte requests into RAM.
Or take LINQ to SQL. LINQ to SQL is great. Usually. If you're using it exactly as they intended. When we wanted to make some of our models automatically supply some query parameters, though...well, let's just say there was a lot of T4 templating involved to get around sealed classes, and leave it there.
I think the successful start-ups are the ones that are most likely to be doing something "weird." And when you're doing something weird, I think that Microsoft is the wrong stack to use.
If you ask me, that's why start-ups tend not to use .NET.
.NET isn't necessarily slow* to work with (GSD, not benchmark wise), but it can be very restrictive and limiting to work with. This is probably great for "enterprise" (whatever that means anymore) where cutting edge technology is considered inherently risky, but in modern startup environments it's just not going to cut it. Community involvement and maturity is part of it too, a talent pool that has a lot more myopic developers who have limited themselves to one language, one framework and one stack is another. Windows as an environment is a third reason, it just doesn't have the same flexibility, tooling and automation of * nix environment. Fun, as a purely subjective reason, is a fourth, I just see * nix devs having more fun with the tools they are using and the stuff they are building.
*though in my own experience the incredibly strict static typing of C#/Java feels slow to me. If I'm trying to design my software well so that it is extensible, understandable and maintainable I find I have far less trouble with this in Ruby, even considering that I have far more skill and experience in C#. That's just my personal experience so YMMV obviously.
I solved what sounds to be a similar problem using reflection and the Linq ExpressionBuilder class(and related classes). It actually turned out really clean and powerful.
The power of Microsoft's tools is that this is possible. The bane of them is that it was necessary in the first place.
I figured out the problem 1) reading the Python code and 2) with what I'd learned about HTTP requests fooling around with curl scripts on the commandline.
No doubt a similar hack is available somehow in .NET / Windows. But I'm not sure that, outside a *nix environment, I'd have known about curl, or played with it enough to learn enough HTTP basics to figure out the problem in the first place.
Umm.... it just delays the cost. That's like saying putting something on a credit card is the same as getting something for free because both "cost" $0. You will end up paying to keep using those tools later on, but the thought is that in 3 years you'll be making enough that it won't matter. And that's probably a reasonable assumption, but it's now yet one more thing that you have to keep track of.
And... true, the cost is somewhat cheaper, but not everyone can take advantage of Bizspark in the first place. So... apply and wait, justify yourself, and perhaps get a pretty good deal on some MS software, or... just go use what a lot of other people are already using for free. It's not hard to see why open source tools win in a lot of situations.
No, not really. I specifically ruled out .NET because BizSpark expires after 3 years or >1 million USD in annual revenue (whichever comes first).
I just don't see a ton of advantage to running .NET/SQLServer/etc over something like Java/PostgreSQL/etc. I'm sure some .NET dev will disagree.
There's just so much flexibility in being able to spin up as many instances as I want without licensing restrictions. For example, a .NET deployment might require larger instances to decrease the per-machine licensing costs, whereas I can do whatever-the-hell-I-want with an open source stack.
BizSpark is free only if you expect to not be around in 3 years.
That's not really the point of BizSpark. It's to get you to the point where SW licenses aren't a huge expenditure. At my company we have a general policy on SW "If it will make you more productive -- buy it." No questions asked.
We spend over $200k/year on each developer. Almost no developer purchases $10k/year in SW, but if they did, it's really not that big of a cost for us. And if there's a small improvement in productivity it's worth it.
But for companies where everyone eats ramen, but only when on sale, the cost of licenses is a big deal. I've seen startups where they require each dev to buy their own machines. I've seen other startups that pay half their annual salary for the first year and then will double your salary the next year -- as a way to get out the gate with lower costs.
If MS SW has no value then it has no value if its free. But if it does have value then the license costs really aren't that substantial.
But so do Rails / Grails / Java / Django / MySQL / PostgreSQL / Redis / Cassandra / Linux / et al., with zero licensing cost (or headache), better deployment flexibility, and the ability to customize them or fix any bugs that are in your way.
Certainly arguments can be made one way or the other on which stack provides more value in terms of time/labor/skills/flexibility, etc.
That said, the article was much to quick to dismiss cost as a factor due to BizSpark.
I have a hard time believing that a company looked and said, "The .NET stack gives us more value, but lets save a few bucks and go with this other stack." Except for early-ramen startups.
My major point was that BizSpark tries take this issue off the table in the early days when you might be cost sensitive. But no value judgment between .NET and other stacks.
To add to your point, from the BizSpark FAQ: " BizSpark software is for design, development, test, and demo only." You have no licence to use the software for any internal business use. E.g. sales guy can't use Office. The licence has so many catch-alls to prevent "abuse" that what you can do is rediculously limited.
Of course, the activated software is very useful, and obviously MS isn't actually enforcing the rules... [edit] so BizSpark can be very handy during first few years, but indeed you are punting a big licencing hassle (staff times number of VMs).
Ding ding ding, we have a winner. It's more about which tribe you want to belong to than anything these days.
I ultimately switched to Python not because I wanted to be part of the cabal of Pythonistas (which I frankly believe is much less 'cool' than Ruby), but because it has exceptional platform coverage, is highly readable - solving a problem I've had working with teams or with old code, and is easy to get up to speed in. Mainly though, it allows me to run my code in the cheapest way possible, and scale for pennies on the dollar compared to .Net.
I love Visual Studio, and I'm more than happy to write .Net code (though I haven't done it in awhile,) but I won't for my personal projects because the resulting product is prohibitively more expensive to run and operate than one built in a variety of other languages.
This argument bothers me because it implies that somehow people are not being objective. Well, the truth is you'll never get anything done unless you form opinions and move forward, but that doesn't mean they don't have good reasons besides peer influence.
Personally I have never programmed on a Microsoft stack because I don't want to be hostage to the whims and resource allocation of one company. With open source frameworks I know that the project quality is a goal unto itself, whereas a Microsoft project lives or dies by its ability to contribute to their larger strategy. With open source the worst case scenario is that the community dies and I have to fix problems myself. Unless there's a compelling reason to go with a proprietary stack (eg. access to the iOS App Store or Windows) then I'll go open source every time, and not just because my friends do.
If you base your infrastructure around Microsoft technology, you're essentially stuck in MSland. Of course, since you're using .NET, you must also have Windows servers and IIS. If you need persistent storage, MS says to use MS SQL Server. You could use other things, but then you're going outside the lines.
OTOH, if you build using free tools, you can change as needs demand. Apache httpd suddenly a little too heavyweight for your needs? Switch to nginx! MySQL working okay but you need geospatial queries, for instance? Migrate to PostgreSQL.
Or how about the ability to run Redis natively, or access to a POSIX environment that literally every other major operating system supports?
If technology isn't playing a role in your technology decisions, you're doing it wrong.
I've been in BizSpark for almost 3 years now (graduation date is April 2012), and hopefully I can add a bit to the conversation. I'll caveat this with the fact that I primarily develop on a MacBook these days and my target environment for most projects is Ubuntu or Debian, in Java and Ruby. However, I still do a fair bit of .NET work, and when I signed up for BizSpark I had the intention of building some .NET products with it. The ultimate reason why I moved on (and this has actually changed since then) from that original idea was that it was a pain in the rear to find a host who would honor your BizSpark licenses. So the choice was either try and deal with that mess, or buy my own gear and run my own infrastructure. I prefer to bootstrap, so like I said, I've moved on.
Anyway, on the cost of BizSpark - you get to keep all the production licenses you spin up in the 3 years or pre-1 million mark. Even if you graduate early, you get to keep, for free, all of those licenses and use the for perpetuity. On top of that, MS (at least for my account, but I'd assume others) has waived the $100 graduation "fee".
That means I've gotten 4 Windows Server and SQL Standard processor licenses for free, which I can use perpetually with no cost. I can also keep all of the dev tools, etc that I was granted via BizSpark, at no cost. And with folks like Amazon now allowing you to supply your own licenses, it makes it easier to put those Windows licenses to work.
I really enjoyed the .NET development I did. The platform has issues like any other, but presents a really integrated environment for just getting something together and getting it out there, and allowing for a pretty significant cost for performance ratio that is supplemented by a really nice core platform (I'm a fan of C#, in particular).
It's not that it's overly expensive to buy the Microsoft software, it's not free, but it's also not completely unreasonable. However, if you're able to find a good .Net developer, very often that same person isn't a good Windows Server administrator. Developers who know their way around languages like PHP, Perl or Python are also often more than capable of deploying the servers that are required to run the code later on.
A good Windows administrator cost money, a lot of money. A decent Linux administrator often comes bundled with the developer.
Of cause this isn't always the case that .Net developers are not qualified to run the servers, but I do run into them rather often. I'm meet excellent .Net developers that are completely incapable of configuring IIS, but I've never see a PHP programmer that couldn't setup Apache or a Python developer that couldn't deploy a wsgi application and fire up nginx.
That being said, culture might be the biggest factor of them all.
Almost all PHP devs are webdevs. Only a small subset of .NET devs are webdevs. It's probably better to compare ASP.NET devs to PHP devs. And most ASP.NET devs can configure IIS.
I'm glad that you found that most ASP.NET developers can configure IIS, but that's not my experience. Getting a site running is something that most can do, but there's a large cap between: "Hey it runs" and "I trust that this will perform and be secure in production and should any issue arise I can debug it and solve the problem".
But yes, I should have written that I was talking about ASP.NET developers.
Business Guy: Hands Microsoft a bunch of money, launches site on an ASP server with 64GB RAM. He is basically done with IT for the first few years of growth.
MIT Genius: Starts off trying to build a system that will scale, from the beginning. He creates about 6 months of IT work for himself. It works, eventually, but it was a lot harder than what the business guy had to do.
Really, you have inspired me to write trac openid plugin :-)
Overall smart plan looks good in many cases but there are things you can't prototype in couple of days. E.g. dropbox or rescuetime like services. If you do it poor nobody will care. Should you make conclusion that nobody cares? I have personally written rescuetime like program for myself but have not seen bussiness oportunity there. Actually I have not cared about that at all and friends to whom I shown it have not proposed to make bussiness out of it.
But I do believe is cultural. We are building a start-up with several pieces of the service in .Net. And it has been extremely fast for us development wise. We are a team of multidisciplinary developers, and we decided to go with .Net for so many reasons; one of them was speed of development and speed of execution. And it has been great so far.
The weird thing is that we are considering using other technologies for specific problems, like C low level execution, but Ruby hasn't yet been found needed; at least not yet.
We believe that as a developer solving a problem we must choose the best tool for the job, and we believe culturally that is what should be promoted. Ruby, Python, PHP, Asp.Net, C#, Java, C++, Lisp, etc. They are only tools to achieve a goal.
Startups should strive to be problem solvers, not technology evangelists.
A lot of people who like *nix are precluded from it, without some sort of major workflow change. After getting excited about OSS languages, it's hard to just dump that and go full-stack Microsoft. Hell, a place I just interviewed at literally has everything through Microsoft that's feasible. IIS to the damn mice. And SourceSafe.
I do agree, the OSS stack for .Net is not as nice as Microsoft's, but in my case I mostly do everything with Emacs anyways, so it doesn't bother me. MonoDevelop is not bad though.
Unofficial, but actually pretty decent (if you are into IDEs) is MonoDevelop.
Why don't startups use erlang? Or postgresql? Or lua?
Developers learn from each other. And they learn based on their work experience. A small team of developers or a single developer makes something using a given set of technologies and then more people are hired to work on it and those people then learn that technology and become proficient with it. And then maybe those developers go elsewhere to start other projects with that technology. It's the same with every skill and every technology.
People use what they know, and they acquire new skills largely from the influence of others. Thus there are skills and technologies that are more popular than others.
P.S. It doesn't help that there are significant roadblocks to switching to .NET such as a change of operating systems (or trying to work with mono) and licensing costs and hassle.
I do agree that programmers should be generalists so they can quickly adapt to new languages and frameworks.
There are plenty of successful startups on the Microsoft stack. Everybody knows about the Stack Overflow story, but there are a lot more examples under the radar. Especially little ventures started by business people (who sometimes seem to prefer the Microsoft stack) that do quite well financially, but may not be very innovative on a technical level. It is just as viable in terms of getting things done and that is the only thing that matters. Admittedly, it may be harder to find good hackers with .NET experience, but the same goes for Java these days and Facebook is even successful in hiring smart people that are willing to work with PHP. Java and .NET are obviously popular with uninspired "bread programmers" because they are the path of least resistance to a safe 9-to-5 job, but that doesn't mean that all Java or .NET work is boring (consider e.g. Java at Google or Twitter).
I wouldn't want to personally depend on the likes of Microsoft or Apple for my development stack because I wouldn't bet my company on anything that isn't free as in freedom, but from my point of view as a casual observer the .NET platform is a pretty impressive piece of technology. Just like some other initiatives by Microsoft, like MSSQL things that come out of Microsft Research (e.g. Simon Peyton-Jones is employed there).
And we use .Net for our startup :)
co-founder of a very-recently Google & Atlas Venture backed startup (so not an investment deterrent; no issues on the engineering deep-dive during diligence, and received kudos on our architecture and some clever stuff we developed). love .NET and the MSFT support & team over at azure... been on it since beta circa 09'. I'm also an avid python numpy & matlab programmer, even submit patches to and support a few open source python libraries (ps: flask is my favorite web framework).
in this discourse (and that of the original article and its comments) of the original article) I've encountered a tremendous amount of opinion/perspective that contrast my own/teams, and the experiences we've had - so I'm sharing my thoughts below. I may not address each questions but it's at least a stream of consciousness evoked by the topic.
(btw: I came from an all-java shop (oracle) by way of a company they acquired in '07.)
our language is C#, target framework 4.0.
- misc: C# is semantically equivalent to Java, virtually the same for the core libraries; syntax and the nuance of the latter aside it's easy to embrace engineers from the opposing worlds within each others framework. - diamonds in the rough: there is a treasure-trove of very smart previously inaccessible engineers toiling away in corporate waste-land, skilled in C#, and ineligible (by syntax/familiarity guidelines) for lots of startup reqs. example: we have a brilliant mathematician on our team that's been coding in C# since its release, working for investment banks where C# was the internal language of choice. as always, it's really about the person, not the language (look at what php's done to push the envelope with PHP... mysql...).
- .NET in terms of limited capability: we've written some pretty heavy non-linear optimization frameworks, stuff that while easy to prototype in python, we've found much more maintainable in C# due to the VS IDE, static typing, and the effectiveness & patterns they beget. also the efficiency inherent in some of the data structures to their static nature has been noticeably performant. (btw, latest CLR has truly dynamic types, and an independent fully dynamic runtime DLR.)
- prototyping: django's beautiful admin framework aside, .NET MVC 2 via C# and Django via Python yield very similar efforts for prototyping. MVC has a struts-like template for pushing admin stuff up quickly.
- cool/weird stuff: we've built (and had one of the best software engineering companies attest to) an incredibly innovative multi-dimensional-map for 'moving' throughout a highly constrained NP solution space during non-linear optimization. C# and Java do not support generic generics (think maps of N # of maps with X type). we have code-generate this, and their super efficient. it's something you could just bang away on at python or in lisp to prototype quickly, but you would need careful optimize and code to get performant, and also maintainable and provable (mathematically) across a multitude of types inherited for varying different sources throughout a framework. object-oriented languages w/static typing afford you this. yes it could have been done in open source C++, C or Java, but we did do it in .NET. It's one of the fun and weird things we've worked on. inspiration is/should not be limited by a language, regardless if it's correlated, it's not causal. please see auto vector regression by one of this years nobel laureate in economics or this: http://www.venganza.org/about/open-letter/ - for quick intuition as to why. :]
- liquidity/exit event, and the choice: we didn't choose .NET due to a likelihood of acquisition, or not choose it in fear of it preventing one (I mean this as in every sense except that in which .NET made our business look more compelling; hone our competitive advantage, etc.) I agree for a framework company (solely depending upon the level of the framework) this could be critical, but for most companies where at least one level of abstraction (framework included) obviates development platform dependency from a decision to use the service, it's negligible. we chose it because of how pervasive windows and its embedded and compact environments were in some of the disparate systems we're integrating with. it made life easier. it's worth stating that, whilst I stand by my first sentence, a couple of our most likely acquirers do have predominantly microsoft stacks, or are c++ based and could assimilate our development ethos quickly.
- cost of tech: we're bizspark'd which made this venture possible, I agree, without that .NET would not have been feasible decision. we would have went java or python (especially given the fantastic client-side deployments dropbox was doing w/it at the time). we would not have chosen MONO - at the time ASP.NET via Mono scaled poorly and MVC didn't exist for it (digression: absolutely no way in hell anyone should build on the old asp.net forms paradigm or hold it against .NET now that MVC is an option: even excluding the IoC weirdness and its terrible pattern, I still cringe when I see .aspx extension on a site. that said MONO for our integration platform would have been perfectly fine.
- long term cost (post 3 years): azure is not expensive, like all platforms (I have EC2 and app-engine experience) if you optimize for it, you can make it cost-effective. more importantly, if you're not earning $ or in some cases raise/preserve capital after 3 years (or until you hit $1.5m in rev per the bizspark restrictions) what kind of business are running?
- source control: TFS (team foundation server) is fantastic, from its testing framework, bug repository, and with some hacking its workflow systems it's a tool I've found as powerful (but easier to configure) than clear case, the systems we used at oracle, and myriad other variants I've worked with over the years. it's not source safe :].
- complexity: we've had to lift up the hood quite a bit to accomplish what we wanted. "the ability to patch and pull in req's for changes to FOSS software" is but one way to customize. .NET offers many, down to the many ways you can override/overload/extend even the most isolated libraries with the latest syntax sugar, to getting your hands a little dirty in MSIL. while not the FOSS way, it's possible. whether or not it's ideal is a matter of perception - e.g. when you work in (and accept) a proprietary environment.
- developer vs. engineer culture: semantics here. probably the b&b of this article, I think culture, pervasiveness (not independent of the former), and founding team/CTO experience, and biz strategy sum up to the decision as to why people do or do not use .NET. I find it difficult to place a coefficient on each of those terms but it's empirically manifest that more often than not they weigh against the choice to use .NET. strategy includes cost, only recently (~3 yrs) obviated by bizspark. it's also the market stuff I mentioned. FOSS has existed for years as an alternative - this is why it's pervaded (among other reasons). I have no data on founder XP, but I've met very few others that have experience working in .NET languages, I think this is a big contributor to start culture & personality types and where most .NET developers dwell - that's why I labeled that intersection 'diamonds in the rough'. last statement should show how those terms are not mutually exclusive.
- language/tech zealots: agreed, they're everywhere. even people I respect tremendously just have this natural predilection toward their preferred tech and its advantages.
my .2e-1
observation: have you seen the wonderful and cross-platform [android, ios, win phone] natively compiled .NET tech miguel's team @ xamarin have been working on? I suspect the # of corp clients that are leveraging that tech and the exposure to consumers the app-serving end-devices have will inspire those corp developers to create their own apps eventually... could bring a lot of .NET favoring newcomers (and different demographic) into the startup scene - neither a bad thing.
In the enterprise the cost of software is a small portion of expenses compared to the cost of developers. For a startup or smaller business, things can be different. But there are large chucks of the software development universe where there aren't OSS solutions, nobody wants to donate their time to do the grunge work.
If the scope of what you're doing is such that all other things in consideration are actually equal, you have a very narrow view.
I will not go on to discuss this article. But I want to express a point of view that I have. I am starting to learn programming and for a lot of reasons, I think I rather learn an Open Source technology than a Microsoft one. Microsoft technologies are meant to work together and this will inevitably lead to you getting locked in, in a Microsoft environment. With Open Source technologies you always have options since they are platform agnostic even though they work better in UNIX-like environments. You can run any of the popular programming languages (Lua, Perl, Python, Ruby, etc) that are used in UNIX-like systems on Windows, and the server software used in UNIX-like systems is also available in Windows, but Microsoft technologies are Windows only. Other important difference is that Open Source technologies can be extended by their users, you don't have to beg anyone to extend the features of an Open Source technology.
At this moment my only computing device is an Android smartphone, you can't do much with it right, right. Ha, but guess what you can install Lua, Perl, Python & JRuby. With JRuby you can even access the full Android API. So I am learning Ruby from and with my Android smartphone. I bet I can't do this with Microsoft technologies.
There are also no success stories of Mono on the serverside. If I use Java, I can rest assured that Google and Twitter have solved those problems before me.
Even if you do client development: WPF is perceived to be the only choice for gui c# development, and WPF is pretty complicated.
As much as I dislike the (XML and other) bloat: Java seems like a safe choice to me. Plus, there are going to be new JVM based languages, like Ceylon.
I love .NET, but my startups are all in Ruby / Python.
Without Visual Studio, .NET isn't half as nice a development experience. (I wish Mono would take the same "native UI is important" approach to the desktop IDE as they do to mobile apps).
A local .net guy was telling me the standard MS line of "it's more expensive to use open source than MS software", and cited costs of a support contract for RHEL and MySQL as being through the roof.
"Most companies I know don't pay for annual support contracts for open source software, " said I.
"Well, no enterprise is going to run anything without 24/7 support contracts in place, and MS ends up being a lot cheaper", said he. It went on for a bit after that.
I've not done much MS work in a while, and haven't worked with it in an enterprise-level capacity for a several years. What support do you get just from the license? Or is support a separate purchase/cost?
Separately, I was at a MS-oriented conference a couple years ago and heard a speaker touting that MS was actually cheaper to run for virtual hosting providers, but all virtual hosting providers charge more for Windows-based hosting because they knew they could make more money from Windows people, because they were already accustomed to "paying for software". Apparently it had nothing to do with paying for Windows licenses - even with 'free' Linux distros, his stance was that it was 2-3x more expensive to administer Linux boxes than Windows boxes. I was rather flummoxed, because it went against about 10 years of my own hands-on experience playing in both worlds.
If you ask me, customers don't care what you code in. Only that you solve a need they have.
Most languages are capable.
Most languages have capable frameworks.
Most have open source options.
If a Language+Framework saves you time in one way, it will probably take up some more time in some other place. You can find such examples in probably everything. Assuming reasonably equal developers in any language, choice of Language+Framework is generally preference and opinion.
Any capable developer can learn any Language+Framework. Some are quicker to pick up in the beginning. Some catch you long term if you don't learn them deep.
Very few startups are technically complex enough to benefit from a specific feature of just one platform, to justify that platform alone. Such technically complex enough startups typically use a number of technologies/languages together.
An interesting trend I've noticed is how so many culturally popular rapid development languages (Ruby, Python, Scala, etc.) are becoming a part of the polyglot world through the JVM (JRuby, Jython, etc.).
What would there be left to distract ourselves with from building a startup if Language+Framework was no longer something for us developers to keep ourselves busy with?
Bullshit. Many (mostly larger) customers, do care. They may have security, regulatory or other needs that you must fulfill.
I do appreciate the subtle clarification. Done enough enterprise sales/development cycles too, and a difference can be present :)
I released my first .Net based application when .Net was at version 1.1. I've developed with it consistently since then.
I'm getting ready to release a new SaaS type application in the first half of 2012. It will be based on an open stack. If I had based it on .Net I would most likely be in production now given the advantages of my background.
I would have loved to use Azure as a platform but I had one problem with it. I could not figure out what the cost would be at different usage points. Microsoft has transferred their licensing labyrinth from the Enterprise to the cloud.
BizSpark allows Microsoft to claim that their stack costs the same a FOSS stack but their claim is disingenuous. Once you get past the BizSpark time limit there is a vast nothingness available to software companies looking to plan their future in the cloud on .Net.
1) It is maintained exclusively by 1 company, if MS decide to kill off part of the platform or let it stagnate and you have a huge base of code based on it you are going to be missing out on the cool new stuff the ruby/python etc guys are getting. In the event that MS went bankrupt or decided to totally change their business model (i.e focus on consumer products) you are essentially screwed.
Also if they decide to change how their tools work (even just change the GUI around) your pretty much forced to re-learn it, this happens less on unix.
2) Licensing costs, sure these may not be that significant but they are subject to change and however small they may be you are competing with free.
3) Familiarity, Allot of startups probably hire recent bright college grads. These guys will have used desktop windows at some point, but they are very likely to have also installed Linux/BSD on a spare computer at some point and setup apache etc on it by reading stuff on wikis/blogs even if just for kicks. How many of them are likely to have installed a Windows 08 server on their own computer and figured out how to set it all up properly by reading MCSE manuals? It's somewhat different from setting up Windows desktop. It's also pretty complicated, I once went on a 2 week course with work to learn how to do some things on Windows server, doing roughly the same things on Linux took about 2 hours to figure out (ok , the course was pretty slow paced so 2 weeks might not be fair).
4) It's windows, it has a reputation for security issues. While this may not be as common as it was , it still makes allot of people nervous when I talk about forwarding ports to a Windows box.
5) Lock in, once you are commmited to Windows stack there's not allot you can do to chop and change parts of your stack for other things, like for example use a different kernel or filesystem. On the other hand let's say your running Linux servers and decide to move to BSD (or apache to lighthttpd), most likely much less of a hassle.
To overcome these things they would need some serious selling points.
Other than backwards compatibility with older stuff is there really a good reason that MS needs to build it's own OS kernel etc?
If they announced tomorrow that the next version of Windows Server would run a BSD kernel but they would port .Net + Active Directory + Windows GUI and everything else over to it would anything really be lost?
Ultimately, the .NET toolset is just not as flexible. If you want to do anything outside of its intended use cases, it requires so much extra work and code. What took me a weeks worth of time took me 1/2 a day in Rails for example.
It looks like people at Microsoft are listening in a way by embracing Javascript. I'd be really interested to see where their nodejs effort ends up in a year.
As with any application or system being built, the available options for building said application should be evaluated and compared for strengths/weaknesses. Whether those fit into an organization's plans is for the organization to decide.
If you choose python you can deploy to Linx/BSD/Solaris or even Windows. Also you get a nice choice of HTTP servers to run it on.
Unless you're suggesting a platform that rules them all?
Want to port your RoR + pgSQL app from Linux over to a Windows server with IIS? Sure you can.
Want to port your .Net + SQL Server app over from Windows to Linux + Apache? Ouch. (well maybe you can use Mono)
Yes, you have to make that consideration. Which was the point of my original comment -- you have to evaluate the whole in creating any application.
> Want to port your RoR + pgSQL app from Linux over to a Windows server with IIS? Sure you can.
> Want to port your .Net + SQL Server app over from Windows to Linux + Apache? Ouch. (well maybe you can use Mono)
This type of commentary is actually a signal I use in candidate interviews. Such generalizations and their inference tells me what working experience a candidate holds.
The level of ease to which you're inferring has to do with the code that's written, not the platform. I've fixed plenty of f'd up applications in my day, and it wasn't the technology stack's problem.
In short, I find the arrows haven't so much to do with this as the archers.
More the point is that if I'm building a brand new "green field" project and I am deciding on technology to use the proprietary and general "locked togetherness" of the MS stack doesn't mean that I definitely won't choose it or that my app will suck because of it but it does mean that the bar it has to reach in terms of technology or productivity is higher than that of a more interchangeable open source/unix solution.
So that is really my response to "Why anyone evaluates .Net as something uniquely different to other languages/frameworks/platforms is beyond me." Because .Net is the only stack that forces the entire stack on you. OK I'm sure there are others but most of those would not even be on a startups radar in terms of tech solutions.
The platform will always be an issue if I can't just rip it out and replace it when either the vendor loses interest in it or it doesn't provide feature X that I want/need.
Even the most well designed application can't be ported to a platform that simply lacks a complete runtime for it. The best you can hope for is to build the new parts of the code in something else and keep a legacy system running for the proprietary stuff integrate it together and slowly migrate over time.
As a hiring manager I want developers who are interested in their craft beyond merely what they learned in school. Seeing experience with obscure tech or less popular languages is an easy way to spot this.
Assuming the candidate can back up what they say on the resume, it shows that they have enough confidence and ability to go off the beaten path.
--Bizspark/Azure-- We signed up for Azure, which took about 10 minutes to fill out a couple web forms describing what we were doing and provided a link to our "coming soon" page. Five days later we were accepted and within 30 minutes we had our Ultimate MSDN subscription and Azure account created. But it wasn't really about the MSDN subscription (which is a nice bonus, though), as we already had Windows 7 installed and we could have used the Express development products just as well as the ultimate ones. In terms of licensing long term, we're not using any of the server licensing, as everything is hosted on Azure. So we'll never have to endure the licensing hell people have referred to. If in 3 years we're not able to pay our hosting bill on Azure then it's time to stop on working on this startup.
On Azure we're taking advantage of the two compute instances, the SQL Server database, and the Blob storage. That's a powerful hosting framework for free. The other options we were considering was Google App Engine with Python/Django, or Heroku with Rails. We had decided on those 3 options because we didn't want to be sysadmins or feel like we needed to hire one. We wanted scability without having to think about it. And since we're not working on a 100 million user project we're not going to need super-customized server optimizations. Being pragmatic about it, going with GAE or Heroku would have been more expensive than free and would have required us to use languages and frameworks we were not 100% familiar with.
--Using what you know-- We would have been deciding to use Rails or Django "just because" with no real benefit. Building a new product is hard enough without trying to learn a new language/framework/server/os. In the past few years I've experimented with Ruby on Rails and various Python frameworks hoping to discover for myself the magic that had captured the hearts of so many developers, but I always kept coming back to .NET when it was a project that required me to be at my best. Deep down I think I wanted to fall in love with Rails or Django because I prefer living in OSX over Win7. Rails just felt like a mess to me, and Django just didn't click. While there is a lot to like about Ruby and Python, my 7 years of experience using C# pays dividends in productivity.
--Lock-in-- People always mention "lock-in" when talking about .NET. But the truth is that there is lock-in with whatever technology you sink your time into. If you spend 6 months building a product in Rails/MySQL/Linux you're just as locked in as you would be if you spent 6 months building in .NET/SQL Server/Win64. Many of the commenters have talked about needing to tweak the OS, tweak the web server, tweak the database server, etc. If you're a new startup worrying about that, then you've already set yourself up for failure through premature optimization. Focus on building your product and getting a few paid users.
Many have also stated that going with .NET means being stuck in MSland and unable to mix and match tech like you would be in OSSland. I think that's a false dichotomy. If we're talking about mixing a web framework with a database, for example, it's very easy to use .NET with Oracle, MySQL, Postgresql, MongoDB, etc. In fact, it's probably easier than with Rails or Django where I remember having a heck of time getting drivers to compile on my Mac. And these days, it's fairly common to use OSS tools with .NET. Microsoft's own ASP.Net MVC, NUnit, Specflow, jQuery, Sass, Coffeescript, etc., to name a few.
But this blog post is just rambling... Why isn't .NET used? Non-techies making technical decisions, or they're hipsters and want to join the PHP or Ruby pain train.
The fact is, .NET can allow you to develop faster than anything else, so these folks are casting about for excuses.
The alternative? Try CodeIgniter for PHP... that's a decent framework!