So far everything has gone pretty smooth. ASP.NET Core is running under the hood which seems to be pretty mature. F# and the libraries that I work with all provide a functional development experience. I interface with a Postgres database, so there's libraries for that as well.
You mentioned Domain-Driven Design. I would recommend reading Scott Wlaschins book Domain Modeling Made Functional [1].
If you are interested in playing around with F#, a quick way to start would be to try SAFE stack [2].
From what I have read during the last couple of months, MS seems to be interested in pushing F# as one of their go-to languages for machine learning. At least they have an F# example online [3], which can not be said for most other areas where F# would also be a good fit in my opinion.
[1] https://fsharpforfunandprofit.com/books/ [2] https://safe-stack.github.io [3] https://dotnet.microsoft.com/apps/machinelearning-ai/ml-dotn...
I don't plan to hire anyone in the foreseeable future but what I can say is that there's 2 people happily working on the F# codebase at the moment, that do not have any prior experience in the language (professional Swift/ObjC background and played around with other languages). Getting into it is quite easy if you're interested in FP. I wouldn't worry too much about that. Just get some people who are experienced in .NET and some people who are good in FP.
> limited support by tools beyond Microsoft ecosystem (e.g., by JetBrains products)
I use JetBrains Rider on a Mac, without major problems so far
Do not worry about the pool. The limiting factor in finding good people is the good part not the programming language.
Re: finding good people - I certainly agree with importance of focusing on the good part. However, still ... having a significantly larger pool of developers statistically increases chances to find good ones (which is important, especially considering competition with big tech firms in hiring engineering talent).
I mean, if I see a good developer who is interested in learning F#, that means I have found a good developer who is interested in learning something off the beaten path.
For certain organizations that is exactly what they need.
Developers that just want to pay the bills learn the popular languages: Python, javascript, Java, C#, Swift, etc. Developers who plays with (or maybe find little projects to do with) the like of F# are statistically more likely to care about their craft, even if they don't necessarily have the possibility to use these at their current jobs.
If someone contact you specifically because they want to use an FP language, but they can't at their current job, it's a very good sign. Of course if you limit yourself to something like: 5 years of experience writing F# in insert field of interest here, it's going to be very tough to hire anyone...
My organisations job ad is looking for people with "several years of programming experience by the way we do things in C# and F# but do not expect you to have".
Then we weed out the huge majority by issuing a tiny take-home code test (think a few fizzbuzz-style questions) that applicants can complete in whatever language or environment they want.
So far, we've received positive feedback on the approach, but also very few truly talented applicants. I think the latter is because we're extremely picky, but I don't know.
What I do know is that we wouldn't get better or more qualified applicants by limiting our search to a few languages. Some of the best so far have come with a language we would never have thought to list.
I believe it's worth it, but have no data to back it up.
There is certainly a higher factor of high talent in FP capable programmers but at the same time the risk for bad hires due to lacking people skills or overly dogmatic work style increases.
It's incredibly fast and productive and has allowed me to create more as a single-person than entire teams using other languages. That still remains true today, even more so as it removes many of the limitations of the Windows-only desktop framework.
Even if you can't use C#/.NET for all the functionality you need, there are many ways to interface with other stacks from function calls, inter-process communication, RPC frameworks, etc. It's well-supported and very common now with the rise of microservices anyway. For AI/ML specifically, I suggest looking at the Machine Learning docs which list plenty of projects like ML.NET and integrations for Tensorflow and Spark.
Another startup founder and CTO here. Can confirm this. Once you get to know the framework, it's really hard to describe how productive you can become. Static type checking, fast compile times, LINQ!, ... It's a 10x ecosystem in the hands of competent developers.
So, our back-end and business logic is in .netcore/C#. Our front-end is a desktop app written in Java 11/JavaFX. The two communicate with a thin IPC layer (stdio pipes). With "new" java (11 and onwards) I'm almost as productive as with C#. If C#/.net is 10x, I'd rate Java as 8x.
And yes, using a statically typed language with strict typechecking (i.e., no implicit integral conversions like in C and C++) leads to programs that feel "engineered" (I wouldn't say overengineered) but which are easy to confidently refactor and build upon.
IOW, flexible/productinve language + static typing + good IDE (VS) = easy to develop "obviously correct" code that works when it compiles and which obviates the need for a huge battery of tests. IME.
But nothing I say will be as useful as just working with it. Try spending a few hours working with some of the bigger frameworks and I'm sure you'll get it pretty quick. If you need help then there are plenty of people to ask as well, from HN to twitter to the .net repos.
Now the question becomes whether it is worth spending time and effort learning more in terms of design patterns, DDD (maybe even CQRS and Event Sourcing) and specifics of these large third-party frameworks as well as practicing working with all that with a benefit of developing really solid enterprise-ready SaaS platform from the start VERSUS moving much faster by developing a more lightweight MVP in Python/FastAPI stack (with PostgreSQL / GraphQL / Vue in both cases) - still with basic/core enterprise features like cloud-native scalability (using Docker swarm mode) and multi-tenancy (using PostgreSQL row-level security) - with a disadvantage of having somewhat less solid architecture and/or some technical debt initially.
There's a lot to enterprise stuff that also has nothing to do with the tech [1] so I would recommend starting with the default asp.net templates and build from there. Move fast and then add in the enterprise specific patterns when you need it.
I don't know if this was the program we used, but you can get a LOT of free stuff from Microsoft as a startup. https://azure.microsoft.com/en-us/overview/startups/
>Between Python and .NET ecosystems, I'm more familiar with the former and, under equal conditions, would choose it over .NET.
I think one thing you need to do when creating a startup is, go with what you know (as you said). You want to decrease the risk that you're product is going to be blocked by encountering an edge case in a framework/language you don't know and you get stuck there for a long time. I am way more familiar with .NET than Python, but I use Python in my spare time and on side projects to build up those muscles.
If you're doing a startup and you want to go .NET, I don't think there's anything holding you back anymore. It's open source now, runs on Linux, and you don't have to pay a dime to develop with it. Microsoft will get you in that, it's WAY easier to pay a little bit to get Visual Studio Enterprise and to then hook that into Azure and all of a sudden you're paying them a ton of money. Yes, that's their master plan. But, no one is making you do that.
Where to stay away from .NET core: Lambdas. The startup time for Lambdas just isn't where it is for other languages, when I last looked at this. If someone has newer data to prove me wrong I'll freaking LOVE YOU FOREVER!
Anyway, depending on what and how you're building your startup, .NET maybe a great pick for you depending on your background. I wouldn't force myself to pick up a new ecosystem and do a startup if I was focused on delivering a product I wanted to deliver and not learning something new and cool.
Also Azure isn't really necessary at all considering the ubiquity of Docker and Kubernetes. I've been running .NET programs basically everywhere else other than Azure for a long time.
Microsoft makes is stupid easy to use Azure, but that doesn't preclude how easy it is to use other hosting. It's like, you can have an iPhone and a windows laptop, but it doesn't integrate AS well as iPhone and a Mac.
Radzen also has a component library available: https://blazor.radzen.com/
https://abp.io/ recently added Blazor to their framework that you might want to check out.
Blazor can also run in 2 modes:
1) server-side where the UI is controlled by a websocket (via SignalR) connection to the backend which processes all the logic. Developing complex interfaces becomes much easier because everything runs on the server and the distance between a database query and UI update is very short. Save the verbose JS->API->Backend layers of code.
2) client-side which uses cutting edge WebAssembly to run your app. The WASM version is getting smaller and faster with every release and isn't much bigger than your standard big SPA which also has megabytes of javascript these days. It has a great JSON library and can also support GRPC-Web now for easy RPC.
Copying a C# class to use as a DTO from a database entity is way faster than trying to worry about serializing to a JSON structure while maintaining all the fidelity (like dates, big ints, binary data, etc).
Another example is reusing business logic like validation for data input. Blazor lets you use a single layer of logic instead of using JS-based simple validation on the form and more detailed checks on the server.
We use it for internal business dashboards and devops management tools. The ability to inject & use existing .NET services is pretty incredible in terms of productivity. We now maintain a monorepository because of this reuse potential.
https://docs.microsoft.com/en-us/aspnet/core/blazor/hosting-...
Down side is scaling, but I mostly write B2B apps. And by the time you run into scaling issues in B2B SaaS someone's rich.
Yes, I have. I've been programming with C# since it was first released, so we're very well acquainted, and I can build MVPs quickly. As always though, it depends what you are used to.
> I'm seeing .NET as predominantly an enterprise-focused technology
I didn't see it as any more enterprise-focused than Java, andid say less so since dotnet core brought multi-platform support.
https://cloudblogs.microsoft.com/opensource/2020/09/08/open-...
We might decide to add PyTorch support, if its adoption will continue to accelerate. But that won't happen for at least a year.
Why?
*) Having said that, from the performance perspective, .NET Core and Julia (from my options) are certainly much more tempting.
As much as I'm excited about Julia, I think that both the language and the ecosystem have not yet reached enough maturity and critical mass of developers as well as comprehensive and stable general-purpose libraries and tools to be a safe choice for a startup, which is already a highly risky venture. I have to reduce risks, not add ones.
Between Python and .NET ecosystems, I'm more familiar with the former and, under equal conditions, would choose it over .NET. Additional argument in favor of this decision is that most of advanced ML/AI development is focused on Python high-level interfaces (and ML/AI is certainly a significant part of my future platform's value proposition). However, based on my research and recent .NET experience, I recognize its advantages versus the Python stack in some areas, including native type system support (though pydantic might be good enough for the Python stack; plus, it is used by FastAPI), rich set of native APIs, much better performance, much better support for domain-driven design (DDD), WebAssembly support, and, finally, much better support for developing multi-tenant applications. The last item is especially important in my case, since multi-tenancy and other relevant features (e.g., auditability) are strict requirements and Python ecosystem pales in comparison with .NET in this regard (the only decent project that I ran across is django-tenants, but a) it would force me to use Django and b) it only supports PostgreSQL schema-based multi-tenancy approach).
Would love to hear your opinions and thoughts on the above. Thank you in advance!