.NET appeals to net-new developers, students, and new technologists

[shanselman]

Summary

Regardless of whether a net-new customer is an existing developer or a student, the fact is that they are missing the context of the last 15+ years of .NET developers. They expect a clean, streamlined experience, clear docs, tidy folders, and quick inner- and outer-loops.

Epics

Epics under this Theme:

• [ ] CompSci 100-200 level classes can be taught entirely in .NET Notebooks in VS Code
• [ ] Necessary tools are easy to find, install, and immediately get started.
• [ ] Documentation provides a rich set of reference and tutorial-based content to learn task-based learning
• [ ] Next-step tasks are easy to discover and intuitive
• [ ] Developers know how to easily deploy their apps/libraries to their endpoints
• [ ] Conceptual Computer Science learning in .NET is more interactive and easier to acquire.
• [ ] New developers can easily find and run their output of their simple app
• [ ] Developers can be successful creating their first project using tools
• [ ] New developers don't have to rationalize .NET Framework vs. .NET Core in Visual Studio
• [ ] https://github.com/dotnet/msbuild/issues/8370
• [ ] https://github.com/dotnet/templating/issues/6023

[webczat]

uhm my experience is specifically that csharp docs are actually a bit messy. Tutorials just cover the very beginning (helloworld), then go into more specific "how to do X" things, but if you want to learn the actual language then the concept/reference docs are a bit confusing. like topics duplicated on concepts and programming guide, or sometimes cross linked, or some things shown only in concepts, and there is no clear order to follow when you are trying to do more concept based learning. Also I believe the situation when you are learning something (for example constructors) and the example of constructors is written so that it uses some features of c# you are not necessarily supposed to be learning at the moment (like generics or something). I mean I believe I saw examples of that, but I don't currently have any specific one at hand, just describing the mechanism.

[t-eckert]

.Net 5 allowing boilerplate around Main to be omitted is a subtle boon for this goal. I started learning programming with Java in 2013. When I encountered boilerplate like that early on, my most frequent reaction was "...well why do I have to write all this?" and my professor's response was mostly "just because". It will be interesting to see what subtle changes like that could have massive impacts in uptake.

[IntegerMan]

I love that this is a central priority for the team. It's important. Kudos to you all on prioritizing it.

[mairaw]

Tagging @BillWagner for the docs feedback

[BillWagner]

@webczat That's valid criticism. We're working on updating the organization so that its more focused on learning paths. One area I'm struggling with in organizing the content is when (or if) to focus on different application types. There's only so many console apps people want to write, but once you branch to web, desktop, games, or other areas, we start to lose some of the audience. What are your thoughts here? Once we get beyond those first tutorials, how focused are you on the type of application you're building? Does it matter if it's different than your goals?

[webczat]

Not fully certain I understand the question, especially that I am myself, very strongly, a concept/reference/apidoc based learner. Like tutorials just to get started (in libraries/technologies), in case of a programming language however, I may even skip them entirely, and I have done so in case of c# especially that I've learned it before. Hmm I believe when I've learned it before tutorials like helloworld didn't even exist. But I wouldn't need them at the point... I am also the kind of person that is not focused on any specific app type, more about things I like/specific domains like networking, lowlevel stuff, but I am interested in web/console/server/gui/whatever else. Does your question cover specifically the c# documentation, or only c# tutorials, or the wider documentation?

[mbuotidem]

@BillWagner You're right that building console apps probably will not sustain engagement. If I were on the docs team writing documentation for newbies like me, I'd focus on things where the reward is visceral and appealing, like web apps and games. In my thinking web apps appeal to new technologists because of the fast feedback loop and the fact that all that's needed to show work in progress is a link. This helps such individuals build a portfolio and sustain their interest. Another reason web apps are cool is because there is fairly reasonable path to pivot from them to mobile apps (whether native or just PWA's or basic responsive sites on mobile). One can even envision this path somehow stretching into Desktop apps via a .NET equivalent of Electron if that exists.

As for games, I know many younger students (and even some college students) love games and so a branch that goes down that path would appeal to that demographic as well.

I've learned quite a bit from docs so it really nice that there's an effort to make them even better. I think some areas that are often frustrating with docs are samples that don't quite work on first try, docs targeted at beginners that assume more background knowledge than is appropriate for the type of doc in question, and the paucity of docs that go into how to test that your code works beyond just manual testing.

I think if there is going to be a beginner focused docs section, it would be awesome to also have a pool of true beginners or recent beginners (like me, haha) to test out those docs and point out where the "not so obvious" parts that were glossed over are. Slightly related is pruning the backlog of open issues in the docs. Sometimes, I encounter an error, and I want to make a PR to fix it but there's either already PR's that fix that error that have been languishing or the sheer number of open issues makes me doubt my PR will ever see the light of day and so I sadly just move on.

[webczat]

How many people are okay with writing "magic" code? I mean, when beginners would immediately dig into things like doing web apps, then there will be a situation where you begin learning c#, but at the beginning you will be writing tons of code you cannot understand. And it could not be explained to you because you would need to know about classes, attributes etc to understand what you are doing or rather, why. In console apps the only things to learn are write to console/possibly read from console, and the rest is the code you consciously write, you do not have that for any other type of app. Some people are okay with that, but not sure how the learning efford compares.

[mbuotidem]

I think there is an important balance to be struck to ensure that the docs are welcoming to all kinds of beginners. I believe the docs can cater to individuals who want to know all the nitty gritty intricacies first, before they start building and creating, and those who initially want to know just enough to be able to build out their idea.

I don't see anything wrong with having "magic code" in some places if it helps the goal of keeping learners engaged. Ensuring that learners first learn everything before they begin working on real world apps is a really good way to lose a huge swath of learners. If one were to learn everything about a car before driving it, one might never drive it because the subject area is quite large. There is a real value in helping someone learn enough to be 'dangerous' and then they want to keep learning and exploring. Many will eventually double back to learn the "magic code" they might have overlooked on the way.

A good compromise where "magic code" is used would be to have something that says, "This code does X. You don't need to understand it all right now. If you don't fully understand it, don't worry about it just yet. But if you must know what it does, here's a link to [insert link to other doc that explains it]". That way, those who want to understand everything can, and those who want to forge ahead can. And when they are ready, they can return and follow the link to fill out their understanding of the "magic code".

[webczat]

my only concern is the number of this magic code. if there is more magic code than ours etc. but the idea proposed here could likely work, not sure :+1:

[AndyDentFree]

Speaking mostly from the Xamarin Forms space, it users should never be confronted by an unbuildable new project.

If they install an IDE or upgrade it, then the New Project templates within that IDE should always work. If there is additional installation work to be done, eg: updates to Android libraries, it should be clearly communicated as a secondary installation step.

It is a disruptive and disheartening experience for a very experienced developer, to not be able to build something trivial as a smoke test. For a new user, it is catastrophic.

[joewoess]

The experience for beginners isn't that bad in my opinion, especially with top level statements and the online editors embedded on the tutorial pages, but the jump from learning what loops and classes are to bigger goals could use some work,

For people coming from different coding languages I personally miss a short and compact version of the docs (unless I'm missing something). As an example I'll point to the current kotlin docs, which are in my opinion easier to navigate and quickly look up a specific syntax/feature. While the descriptive dotnet documentation is probably giving better insight, most of the time I'm just looking for a specific snippet without being interested in the nitty-gritty details.

As a stepping stone after the initial learning experience I think a guided project would help set them on their way. Guiding a new developer by expanding selectively on a dedicated medium sized tutorial project (for example a simple console chat client. basics, async, networking, I/O, logging, etc.) would probably reduce the early apprehension of people who try to transition to bigger projects and help feel them less lost. Similar to higher school/early uni levels, where you might get a "working" barebones project and then be guided through implementing missing features.

[rspadim]

I think the big entry point to beginners is python language, maybe improve ironpython3 could help a lot this, i'm talking about c# to beginners

The other big community is the kaggle community, maybe improving the c# jupyter notebook integration (or including it at kaggle / colab / etc), and increase ML.net examples could help

List and dict compression is something we should implement too, var x = {i.Key:i.Value.anyvalue foreach(var i in somedict)}; reduce many lines of code that a beginner shouldn't care (maybe this could be done with some dictionary type <string, double>?!)

I don't think aio is something we should care a lot, but the biggest python ecosystem is: flask + fastapi + logging + sklearn + matplotlib + selenium + beautiful soup + redis/mongo/mysql/mariadb/postgresql, that's the biggest points I see in python community

About javascript/node.js i think asp.net is ok we can improve but it's ok

[papyr]

Feature Request: Drop-in component for ASP Identity Administration, Portals, UI, SSO, Claims, AD-Sync, Token, Multi.Tenant Management so that the Visual Studio templates don't require commercial licensed 3rd party components.

I have been watching/waiting few yrs. patiently, however some recent changes have forced me to request -- Microsoft revisit this for their developer community, keeping in mind some of the pricing out there compares to the salaries of 10 to 15 developers in Bangladesh, Vietnam, India, Philippines etc.

Its a Core & Basic need, yet very complex and critical for the developer, with security risks.

There's a void in .NET native drop-in solution, unlike the Java, PHP Stacks etc, where there are many native drop in Identity Administration & Management Frameworks options that are leveraged across all their platforms seamlessly by developers, for e.g. the J2EE Pluggable Identity Management Framework or JSR 168 or JSR 286 or JSR-351 or JSR-375.

Why is this important? because using Java or PHP, it has allowed easy, clear, core and basic functionalities in those native stacks. As a result if you look JSR 168 or JSR 286 or JSR-351 or JSR-375 Multi-tenants, Group to roles, or to claims vice versa is so easy vs. NET , mobile devices, portals, they all work seamlessly and cohesively with security fixes managed by either IBM or SalesForce or Oracle or Red Hat etc. This is enables developer to be productive right out of the gate.

In .Net there is void/very limited support, always requiring a combination of 3rd parties as a barrier to entry & adoption of ASP app. This is non-trivial for developers and security vulnerability that requires the attention of Microsoft Experts.

Example: We have private information sharing site non OSS for the community almost free (pay if you want), and when we started with web forms, then Simple Membership, the Identity, Identity 2 ASP MVC we had implement much of it on top of these from scratch, when we moved to .NET Core it was another effort. Besides the development there was a lot of confusion on the internal concepts and how they now meant new things. Roles, Claims, Federation, SAML then SAML 2.0 and then Open ID 2.

Describe the solution you'd like

1. In-house (Microsoft made) -- A drop-in is extensible solution that supports ASP MVC Identity eco-system, Administration, GUI, SSO, Token, Multi-tenant Management, independent of 3rd party companies and Identity Servers
2. A configuration section to turn on-off the various features.
3. Embedded into VS Templates (remove Identity Server, use native MS option etc.)
4. Allow-Easy AD Active Directory Integration
5. Web page to Create User Defined/Created Fields UDF - dynamic fields in web apps from the web page.
6. SAML2/CAS
7. Allow template option Configuration.MultiTenancy.IsEnabled = true; Global DataFilter for Tenant entities
8. C# ML Streaming & detect events or video Support for e.g. from Kafka
9. Dashboard platform with Widgets and settings
10. Dynamically creating and adding components. Angular ComponentFactoryResolveralternative.
11. Provide a built-in or otherwise framework supplied mechanism for View Components, when rendered via a tag helper, to render user-supplied child content that can be injected into the View Component's view template in pre-defined locations

Its high time MS address this core gate-keeping feature!!

[mairaw]

Bulk closing .NET 6 epics and user stories. If you think this issue was closed in error, please reopen the issue and update it accordingly.