Github Copilot With C# .NET

On the 29th of June 2021, Github Copilot was released to much fanfare. In the many gifs/videos/screenshots from developers across the world, it showed essentially an intellisense on steroids type experience where entire methods could be auto typed for you. It was pretty amazing but I did wonder how much of it was very very specific examples where it shined, and how much it could actually do to help day to day programming.

So off I went to download the extension and….

Access to GitHub Copilot is limited to a small group of testers during the technical preview of GitHub Copilot. If you don’t have access to the technical preview, you will see an error when you try to use this extension.

Boo! But that’s OK. I thought maybe they would open things up fairly quickly. So I signed up at https://copilot.github.com/

Now some 4 months later, I’m finally in! Dreams can come true! If you haven’t yet, sign up to the technical preview and cross your fingers for access soon. But for now you will have to settle for this little write up here!

What do I want to test? Well of the many examples I saw of Github Copilot, I can’t recall any being of C# .NET. There may be many reasons for that, but it does interest me because I think over the course of years, the style in which we develop C# has heavily changed. Just as an example, prior to .NET 4.5, we didn’t have the async/await keywords. But it would almost be impossible to find C# code written today that didn’t use asynchronous programming in one way or another. But if Github Copilot is using the full gamut of C# code written in the past 20 years, it may well fall into bad habits of yesteryear.

Let’s try it out anyway!

Add Two Numbers Together

My first attempt at using Copilot was a simple test. Adding two numbers together. Here’s how Copilot shows you what it thinks you want to do :

You can then press tab to accept the intellisense, much like you normally would in Visual Studio. There can be a bit of a lag between typing and the suggestions showing. It doesn’t “feel” like intellisense like you would with Visual Studio because of this. But it’s still responsive if you want to stop for a second or two and see what it thinks you should do.

Fetch Web Page Contents

Next, I wanted to see if I could trip it up a little by using an async method, but the actual logic was simple. All I wanted to do was to fetch a webpage, and return the string contents. Here’s what it gave me :

Now again, not rocket science, but pretty impressive. It knew that the method itself was async (So it could use await), and that we were using a string so it should return the entire contents.

Let’s say I wanted to get fancy though. Instead of returning the string contents of the page, I want to use HtmlAgilityPack (A common HTML parser) to return the parsed HtmlDocument. Now the thing here is, I 100% thought it was going to load the webpage as normal, and then try and parse it into a document. But instead :

Apparently HtmlAgilityPack has a class called “HtmlWeb” that does this for you. I never would have even known this without Github Copilot. This impressed the bejesus out of me because while yes, it’s a pretty common task, it’s also a third party library that I thought for sure would trip it up.

Code From Comments

One of the most impressive things I saw in Copilot demos was the ability to write a comment, and have it understand what code to write based on that comment alone. Again, this is something that I thought for sure would trip it up but instead :

OK, a pretty simple example but it completely blew my mind that from the comment alone, it knew what to do.

So instead, I tried to break it. I started with the following code. It doesn’t give too much away (I think).

static async Task Main(string[] args)
{
var searchQuery = args[0];
// Go to google and use the search query to find the first result
}

And this time, Copilot fed me line by line to end up like so :

static async Task Main(string[] args)
{
var searchQuery = args[0];
// Go to google and use the search query to find the first result
var url = $”https://www.google.com/search?q={searchQuery}”;
var client = new HttpClient();
var html = await client.GetStringAsync(url);
// Find the first result
var startIndex = html.IndexOf(“<h3 class=”r”>”);
var endIndex = html.IndexOf(“</h3>”, startIndex);
var result = html.Substring(startIndex, endIndex – startIndex);
// Print the result
Console.WriteLine(result);
}

Again, All I did was accept every suggestion by pressing Tab over and over, I did not modify this code at all. And it’s actually pretty good! There’s probably better ways to do this with Regex and/or HtmlAgilityPack, but this is actually pretty nice.

Algorithm Code

This is where I think I’ve seen Copilot shine the most. If you know “I need the algorithm that does XYZ”, Copilot is pretty dang efficient in whipping those up for you.

Here it is writing a quick Bubblesort for you based off nothing but the method name and input :

Amazing!

Sometime back, I wrote about the knapsack algorithm (https://dotnetcoretutorials.com/2020/04/22/knapsack-algorithm-in-c/). Mostly I was fascinated because I had seen the problem come up a lot in programming competitions and I always got stuck. So I took my code from there and started typing it as I did there and…

Legitimately, I think this thing could break programming competitions at times. Imagine the common “Traveling Salesman Problem” or pathfinding as part of a competition. You could almost just write the problem as a comment and let Copilot do the rest.

Github Copilot Final Verdict

I’ll be honest, I came into this being fairly sceptical. Having never had my hands on the actual tool, I had read a lot of other news articles that were fairly polarising. Either Copilot is the next great thing, or it’s just a gimmick. And I have to admit, I think Copilot really does have a place. To me, it’s more than a gimmick. You still need to be a programmer to use it, it’s not going to write code for you, but I think some people out there are really under selling this. It’s pretty fantastic. Be sure to sign up to the technical preview to get your hands on it and try it out for yourself!

The post Github Copilot With C# .NET appeared first on .NET Core Tutorials.

What is CRUD? How to create a CRUD app?

What are CRUD and CRUD operations examples?
CRUD and REST
Parts of the CRUD app
Creating CRUD apps traditional way
Create CRUD app with Flatlogic
Conclustion

Modern web development involves user interaction with databases. As a rule, the user needs to perform some actions with the database. Usually, there are 4 actions: create, view, update and delete something. This is how we come to the acronym CRUD – an abbreviation for these four actions.

If you have ever worked with databases, then for sure you’ve worked with CRUD – even if you didn’t know it. CRUD operations are often used with SQL. Since SQL is very popular in the developer community, it is very important for developers to understand how CRUD operations work.

One good thing about the CRUD paradigm is that it helps the developer build complete applications.

Let’s see how this works with a simple abstract object in any application: we’ll use something like pseudocode to describe this object. We will provide a system for registering students in a college. In this system there will be a “student” object that looks like this (carefully, pseudocode!):

“Student”: {
“id”: <Integer>,
“First_name”: <String>,
“Last_name”: <String>,
“Course”: <String>
}

In order to manage this system, we must perform certain manipulations with the student object. So, let’s move on to the next section where we will describe each CRUD operation in more detail .

Most applications on the internet are actually CRUD applications. For instance, let’s take Facebook as one of the common examples – it’s just a CRUD application where users can create, delete, change information about themselves, and read information about other people. CRUD apps are used on a daily basis by various businesses and organizations to maintain their day-to-day workflows.

What are CRUD and CRUD operations examples?

The CRUD concept was not originally conceived as a modern way to create APIs. CRUD actually has its roots in database records. Most modern web and mobile applications contain some form of CRUD functionality. In addition, most programmers have to deal with CRUD at some point. So, a CRUD application would be one that utilizes forms to retrieve and return data from a database.

A relational database consists of tables with rows and columns. In a relational database, each row in a table is called a record, and each column in the table represents a specific attribute or field. Users can call four CRUD functions to perform different types of operations on selected data in the database. This can be done through code or through GUI. Now, let’s take a look at each function separately.

CREATE – this feature will add a new student to the app/database by some trigger, for example, by pressing the “Add” button in the application, which will call the corresponding function. The program calling the function would supply the values ​​for “first_name”, “last_name”, and “course”. After the function is called, a new student record will appear in the database.

READ – this function allows you to see if there is a record about a specific student in the database. This function does not change the information about the student in any way, but only allows you to get information about him. You can also see a certain attribute.

UPDATE is a function that changes information about a student. Let’s write his name. After the function is applied, the corresponding record in the database table will be changed.

DELETE – of course, everything should be clear here. This function either completely removes the object or removes its selected attribute.

By definition, CRUD is more of a cycle than an architectural concept. There are several CRUD loops in any web application. For example, in an online store, a customer can CREATE an account, UPDATE account information, and DELETE items from the cart. At the same time, a store admin using the same web application can CREATE shipping records, READ them as needed, and UPDATE supply lists.

CRUD and REST

Let’s now take a look at the concept of CRUD in the context of using our favorite web applications. Most often, REST architecture is used to execute CRUD operations in web applications. REST is just a concept, a set of rules. It uses HTTP protocols like GET, PUT, POST to link resources to actions within a client-server relationship. If we apply these rules to the application, then we are already talking about RESTFul.

So, for example, each letter in CRUD can also be mapped to an HTTP protocol method:

OPERATIONS
HTTP PROTOCOL

Create
Post

Read
Get

Update
Put

Delete
Delete

Thus CRUD is a cycle that can be mapped to REST, by design. In a REST environment, CRUD often corresponds to the HTTP methods POST, GET, PUT, and DELETE, respectively.

Parts of the CRUD app

Database

The database is where your data is stored. A database management system is used to manage the database. There are several types of database management systems, which are subdivided depending on how they store data: relational (SQL) and document (NoSQL). In this article, we talk about relational databases. SQL databases consist of tables. Tables consist of records. Records consist of fields. Fields consist of data.

User Interface or Front-end

The front-end, or User Interface, helps people interact with the application and database.

Back-end or APIs

Finally, the back-end informs your database of what functions to perform. These functions can be modeled in different ways, but they are still designed to perform four basic CRUD operations.

Creating CRUD applications traditional way

In order to develop a basic CRUD application from scratch, you will need a fairly good knowledge of javascript or front-end frameworks, one of the programming languages for the back-end, and knowledge of databases. You will also want to know one of the ORMs.

Let’s take a quick look at the steps you will have to go through to write a React + Node.js + PostgreSQL CRUD application.

Prerequisites

Install React;
Install Node.js;
Install PostgreSQL.

Front-end part

Use one of the React starter apps and learn it. For example, it may be created react app;
Install all required modules (react-router, redux, etc.);
Create Initial pages of your application;
Create components that will help perform CRUD functions – buttons, forms, etc.;
Connect the front-end part to back-end;
Setup form validation;
Develop react pagination (optional);
Develop react tables (optional);
Setup fetching the data form created database;
Create entire application styles;
Develop UI/UX of the application (optional);
You should do the client part responsive;
Write tests (optional).

Back-end and database part

Install Node Dependencies;
Setting up PostgreSQL Database;
Define Sequelize Schema;
Create Routes Using ExpressJS (develop REST API).

Hosting

It is one of the hardest parts.

Host the application;
Set up CI/CD.

Almost all of the steps described above apply to other technologies, be it Vue or Angular, Laravel or Python, PostgreSQL, or MySQL.

Guides on how to create a CRUD application

We have also selected for you some of the valuable guides on how to create a custom CRUD app:

CRUD app on Mongo DB and Express;

React CRUD app using React context API;

React + Node.js+ MongoDB CRUD app.

Thus, in order to build even a basic CRUD application, you will need knowledge of several technologies and will have to spend a lot of time studying and developing repetitive work – not to mention new requests for the development of additional features.

In the next section, we will look at an alternative way to develop a CRUD application that will save you a lot of time, not holding you back in the possibilities of customization and ownership of the source code.

Create CRUD app with Flatlogic

In our example, we will build a small-time tracking application with several entities. The application will have a screen with users, projects, and records that will be linked to each other. These entities can be managed using CRUD operations.

Goals

You should be able to build any CRUD application like a time tracking app after this tutorial using Flatlogic Generator;
You should be able to understand basic principles of CRUD concept and database architecture;
You should be able to create your own entities with custom relationships and parameters.

1. Planning the application

Application development with Flatlogic Generator consists of several stages. The first is to actually sort out what kind of application you will make. After that, plan what entities the database will consist of and what this application will be used for.

We mentioned above that we will be developing a time tracking application. Our application will consist of three entities (tables in the database):

Users 

This table will contain users of our application with different roles. Flatlogic Generator creates this table by default and does not prompt to delete it.

Records 

This table will store the time spent records associated with projects and users. We will look at the more detailed contents of this table in the next steps.

Projects

This table will store data about projects. We will also consider filling this table with columns in more detail in the next steps.

2. Register account in Flatlogic Generator

So, for better interaction with Flatlogic Generator, firstly we advise you to create an account on the Flatlogic website before you develop an application.

To create an account on the Flatlogic website, simply click ‘Sign in’ in the header (see screenshot below).

Next, you will be redirected to the account creation page, where you will have 2 options – create an account using email or do it using GitHub integration.

After that, simply confirm the email and begin work with a Flatlogic Generator website. For detailed info on how to interact with your account please refer to the documentation.

3. Choose the stack and project name of CRUD app

This step will allow you to choose your project stack and project name. The stack consists of three parts:

Frontend;
Backend;
Database.

In each part you will have the following options to choose from:

The front end has React, Angular, and Vue frameworks;
Backend for now has only two options – Node.js and Laravel. We are planning to add Java, Python, .NET options;
There are two options for databases: MySQL and PostgreSQL. We are planning to add MongoDB in the near future.

Thus, you have more than 20 options to choose from to create your web application

4. Choose the design

Considering the design, there are five options now: Material, Classic, Transparent, and two of our internal Flatlogic design systems. Please note that some stacks have fewer design options, for example, Angular has only three design options.

5. Define the database schema

To create, manage and store the data related to the time tracking app, we will use Flatlogic Generator schema editor. Flatlogic generator allows you to create content types for the entities in your app. It exposes entities via generated API, which you can use to populate the frontend.

The basic essence of the Scheme Editor is that it consists of tables and columns – in your work you will deal with them.

If you choose to build an application from scratch, then you will see a button to add a table as well as a ready-made default table for Users (since we believe a user exists in any application).

By clicking on the ready-made Users tab, you will see in front of you all the columns created in the table with its properties. In our exemplary time tracking application, the Users entity stays default – we will not add new columns to it.

Working with tables, you have 2 options – add a new table or delete it. Now let’s take a look at each of these steps separately.

When working with columns, you have 3 options – add or remove a column, or change the properties of the column.

Adding Records and Projects tables

As mentioned above, our application should have Records and Projects tables.

So, in order to add a table, you need to press the ‘Add Table‘ button (see screenshot below).

After clicking the button, a new table will be added and you will be prompted to select a name for this table. Please choose the name in lower case. In our case, we need to add two Records and Projects tables.

Adding column

In order to create a column, click on the table in which you want to create a column and then click on the ‘Add column’ button.

When you click on the column, you can edit it. Edit column window with the following parameters will open on the right side (see the screenshot):

Name – here you specify the name of the column that you will see in your database. Please, use a camel case for column names.

Title – title of the column that you will see in your live application. Here you can use capital letters and any names, as this does not affect the generation and operation of the application.

Type – in this menu you can select the data type of the column.

The following types are offered to choose from:

String – when you select this type, you have a unique Multiline option that adds multiple lines;
Int;
Decimal;
Date;
Boolean – when choosing this type, you need to set the value to True or False;
Images;
Datetime.
Relation_one;
Relation_many;
Enum.

Unique – enables or disables the column uniqueness option;

Show in the list – option allows to show the column as a list;

Show in form – allows you to show the column in the form.

So let’s add the following columns according to their tables.

To the Records the table we add the following columns:

Task – this column will contain the names of the completed tasks

Type
String

Ref

Unique
False

Show in Table
True

Show in Form
True

Hours –  a column with the information on time spent on task

Type
Decimal

Ref

Unique
False

Show in Table
True

Show in Form
True

User – a column with data about the user who created the job record. Please note that the type here is relation_one and a link to the users table

Type
relation_one

Ref
users

Unique
False

Show in Table
True

Show in Form
True

Submitted – this column will contain information about the status of the job

Type
boolean

Ref

Unique
False

Show in Table
True

Show in Form
True

Project – a column with information about the project to which the task belongs. The column will also be linked to the projects table

Type
relation_one

Ref
projects

Unique
False

Show in Table
True

Show in Form
True

In the Projects table we add the following columns (see the screenshot below):

Name – in this column, we will store the name of the project. The column must be created with the following parameters

Type
String

Ref

Unique
False

Show in Table
True

Show in Form
True

Rate – a column with information about the hourly rate at which the project is being executed

Type
Decimal

Ref

Unique
False

Show in Table
True

Show in Form
True

Start_date – the column with information is the start date of the project

Type
Date

Ref

Unique
False

Show in Table
True

Show in Form
True

End_date – a column with the date of the end of the project

Type
Date

Ref

Unique
False

Show in Table
True

Show in Form
True

This completes our database schema. Let’s move on to the last step of creating the CRUD application.

6. Create CRUD app

So, after you have defined your database schema, you will be redirected to the final step in the development wizard. All you need in this step is to check your tech stack and design – and then push the ‘Create Project‘ button.

After that, the system will transfer you to the screen with your created projects. At the same time, your application code will already be generated.

By clicking on the project name, you will be taken to the settings page with additional information about the project, where you can familiarize yourself with the following functions.

7. Working with CRUD project/application

Overview of project

After you click on project name you will be taken to the overview of the project page, where you will see information about the project, as well as the various functions you can apply to it.

Download the code to customize

For example, you can download the full source code of a Flatlogic Generator project to continue developing in your favorite IDE. To do this, click on the Download button and get a subscription to one of the paid plans (which can be canceled at any time).

See the live demo

Before downloading the code, you can also watch the live demo of your project. To do this, click on the Deploy button on the overview tab opposite the Live URL line.

Now, the project begins to build. In a few minutes, you will receive a demo of a real working application.

After the application has been created, we can see the result. For example, here are screenshots from the demo of our Time-tracking app, which we created with the Records and Projects entities. In these screenshots, you can see that the application complies with the CRUD concept since we can create new records, modify, delete and view them.

Creating a new record:

See generated API

Along with generating code, Flatlogic Generator creates an API for the generated application. For example, here is a link to the created API for the time-tracking app we created earlier: API for Time-tracking app in Swagger.

Push code to the Github repository

You can push the code of the created application into the GitHub repository, which will be created specifically for the generated application. At the same time, editing the project database schema, Flatlogic Generator will push the new code into the previously created repository.

To connect to Github – click the Push to Github button.

See the code preview

Before subscribing to a project or downloading it, you can see the structure of the project code and the code itself. To do this, click on the Code Preview tab.

Edit the schema of the CRUD application

You can change the database schema of your application an infinite number of times. Click on the Schema tab to go to the schema editor and add/remove/modify entities for your project.

CRUD application settings

In the Settings tab you can do the following:

Change the name of the project;
Add a new subscription;
Download the source code;
Push the code to GitHub;
Activate trial;
Delete Project.

Recap

Thus, we created a CRUD time tracking application based on the Flatlogic Generator and examined the main functions of this app development platform. 

Feel free to try and join Flatlogic Generator! Register your free account and get started today.

If you’d like additional help when building your product, our thriving community forum is a great place to source actionable advice and resources. Or, you can send me your request to [email protected]. All creators are encouraged to ask questions within the community to help empower their journey.

Conclusion

In this article, we learned about the concept of CRUD, explained how to use it in application development, and put it in a REST context. We also looked at two ways to develop a basic CRUD application, the traditional way and the faster way with the Flatlogic Generator.

If you notice any errors in the article or want to supplement it – please contact me. Feedback is always welcome!

The post What is CRUD? How to create a CRUD app? appeared first on Flatlogic Blog.

Dew Drop – October 29, 2021 (#3548)

Top Links

Developer Perspectives Episode 7 | Kayla Cinnamon and Hayden Barnes (Windows Developer Team)

Panos Panay and more: What’s up with Windows at Microsoft Ignite Nov. 2-4 (Steve Clarke)

“Hello Raspberry Pi” Launching Uno Platform Application Directly on the Pi (Uno Platform Team)

Edge DevTools for Visual Studio Code 1.4.0 – Improved Screencasting, Device Emulation and live, inline issue reporting (Chris Heilmann)

Surface at Microsoft Ignite: November 2021 (Frank Buchholz)

Web & Cloud Development

How To Build An Amazon Product Scraper With Node.js (Robert Sfichi)

Binary Data Transfer on Azure Functions via OpenAPI (Justin Yoo)

Azure Service Fabric 8.1 Third Refresh Update (3.1) Release and Azure Service Fabric 8.2 Release (Service Fabric Team)

How To Deploy a React App With Vercel and GitHub—A Step-by-Step Guide (Thomas Findlay)

How to implement Swagger with Authorization (Andrew Hinkle)

Invoice Deployment Strategies: Building an Invoice Portal (Bjoern Meyer)

100 days of TypeScript (Day 3) (Peter O’Hanlon)

WinUI, .NET MAUI & XAML

Windows App SDK Preview 3 Supports Non-MSIX WinUI 3 App Deployment (David Ramel)

Visual Studio & .NET

Make the error useful, and save the support call (Oren Eini)

VS 2022 for Mac Supports .NET 6 RC2 on Intel-based Macs (but Not M1 ARM64) (David Ramel)

Sorting large CSV files by multiple columns using C# (Josef Ottosson)

File-Scoped Namespaces – A Look at New Language Features in C# 10 (Matthias Koch)

Collection Performance: Looping Over Reference Type vs. Value Type and Collection Performance: Adding Items to a Collection and Everything That Every .NET Developer Needs to Know About Disposable Types: Properly Implementing the IDisposable Interface (David McCarter)

Giving a single object multiple COM identities, part 3 (Raymond Chen)

Design, Methodology & Testing

How To Write An Effective Project Plan In 6 Simple Steps (Deanna deBara)

Navigating The “Great Resignation”: How To Retain Employees When No One Else Can (Lydia Durkovic)

The Rise of Event-Driven Architecture (Matthew O’Riordan)

Zero Trust Security and the Software Development Lifecycle (Pavan Belagatti)

7 Best Prototyping Tools for UI/UX Designers in 2021 (Stefan Ivanov)

Mobile, IoT & Game Development

How to create a movie details app using Flutter: part 1 (Anoob Bava)

Raspberry Pi Zero 2 W is a tiny powerhouse, available now at just $15 (Dave W. Shanahan)

Introducing Swift Distributed Actors (Konrad ‘ktoso’ Malawski)

13 short and scary games plus source to play (or hack) this Halloween (Lee Reilly)

Podcasts, Screencasts & Videos

CppCast – C++23 ISO Progress with Bryce Adelstein Lelbach (Rob Irving)

The Stack Overflow Podcast 388: Software for your second brain (Ryan Donovan)

Hanselminutes – Dr. Jelani Nelson – in partnership with ACM Bytecast (Scott Hanselman)

Using TypeConverter with Xamarin.Forms for Better Custom Controls (Gerald Versluis)

Working Code Podcast – Episode 046: Secret Management vs. Premature Optimization (Ben Nadel)

What is exciting in Flexible Server for PostgreSQL on Azure | Data Exposed (Anna Hoffman & Sunil Agarwal)

Azure Podcast Episode 400 – A view from Azure’s Core (Sujit D’Mello)

React Native Radio 216 –  Creating “React Native as a Service” at DraftBit with Peter Piekarczyk (Jamon Holmgren & Mazen Chami)

MidDay Café Episode 25 – Teams Encryption Microsoft Viva and More (Mike Gannotti)

How to Get Started with DevOps – Adventures in DevOps 091 (Jonathan Hall & Will Button)

Rocket 357: Facebook Papers (Christina Warren, Brianna Wu & Simone De Rochefort)

Web Rush Episode 157: Building StackBlitz with Eric Simmons (John Papa, Ward Bell, Dan Wahlin & Craig Shoemaker)

Microsoft Mechanics – Manage All Your Surface Devices in a Single Portal – Microsoft Endpoint Manager (Jeremy Chapman)

Tech News: .NET 6, Windows 11 released, GitHub Advisory Databases, and MacBook Pro 2021 (SSW TV)

Community & Events

Understanding the 2021 State of Open Source Report (Michael Coté)

Data Engineers of Netflix — Interview with Pallavi Phadnis (Netflix Technology Team)

The Top Places to View Holiday Lights in Philadelphia for 2021 (Visit Philly)

Getting To Know Will Johnson, Developer Advocate @ Auth0 (Will Johnson)

Database

SQL SERVER – List All Available TimeZone (Pinal Dave)

Goodbye Microsoft SQL Server, Hello Babelfish (Sébastien Stormacq)

Learning SQL CROSS JOIN with Examples (Jim Evans)

SharePoint & MS Teams

CRUD Operations on a SharePoint List using Python (Nai Biao Zhou)

What’s New in Microsoft Teams for Education | October 2021 (Abby Schilbach)

Preview of Feedback for Microsoft Teams now available (Alex Olsen)

What’s New in Microsoft Teams | October 2021 (Microsoft Teams Team)

PowerShell

PowerShell for the SQL Server DBA – Environment Setup (Alejandro Cobar)

Cloud Service (extended support) management via PowerShell (Yi Yang)

Miscellaneous

Surface Duo 2 most powerful Android phone according to latest Geekbench chart (Arif Bacchus)

Mark Zuckerberg on why Facebook is rebranding to Meta (Alex Heath)

Facebook’s new name will be Meta (Kim Lyons)

Microsoft Edge features help give you the most out of Microsoft 365 to reduce the pain of context switching (Sean Lyndersay & Deb Dubrow)

Microsoft releases PowerToys v0.49 with new mouse utility and UI updates (Sofia Wyciślik-Wilson)

More Link Collections

The Morning Brew #3342 and The Morning Brew #3343 (Chris Alcock)

.NET App Developer Links – 2021-10-28 and .NET App Developer Links – 2021-10-29 (Dan Rigby)

Collective #685 (Mary Lou)

The Geek Shelf

 The Story of Marvel Studios: The Making of the Marvel Cinematic Universe (Tara Bennett & Paul Terry) – Referral Link

Microsoft Contributes MSBuild Engine to the .NET Foundation

The .NET team at Microsoft announced today that they are contributing another new open source project to the .NET Foundation — the Microsoft Build Engine (MSBuild), available today on GitHub.

MSBuild is a platform for building applications, and the default build engine for Visual Studio and the .NET community on the Windows platform. It enables developers to orchestrate and build products in environments where Visual Studio isn’t installed. Through open sourcing MSBuild, the team intends to make it a top choice for .NET developers on the Linux and Mac platforms.

The team reports that community feedback led them to open source MSBuild, and through the .NET Foundation, they hope to continue this collaboration.

Get involved in MSBuild, and keep the comments flowing on the .NET Foundation Forums.

Read more about the open sourcing of MSBuild on the .NET team blog.

 

Robin Ginn

Director, Technical Evangelism, Microsoft Open Technologies

.NET Foundation Welcomes Executive Director Martin Woodward

Time flies. Exactly one year ago today, Microsoft Corp. announced the creation of an independent .NET Foundation to foster open development and collaboration around the Microsoft .NET development framework. At the end of February we announced our Advisory Council, a group of nine leaders who are bringing their passion and experience to help steward the future of .NET as an open source community. Today, I am pleased to announce that the .NET Foundation Board appointed a full time Executive Director to the .NET Foundation: Martin Woodward.

In his new role, Martin will remain an employee of Microsoft, where he has been involved in the open source world for some time. He came from the Microsoft MVP community where he worked on Eclipse, Java, Unix and Mac tooling for Team Foundation Server, bringing this functionality to Microsoft’s Developer Division. He helped drive the introduction of Git to Microsoft and ensured it was done in collaboration with the open source community. Behind the scenes, Martin lent his expertise to several Microsoft open source initiatives that you’re familiar with, including some of the projects brought into the .NET Foundation. Additionally, he has been part of a cross-company effort to improve the internal processes and tooling at Microsoft, enabling the company to do more in the open source space.

Over the past year, we have been honored by the level of community involvement in the .NET Foundation. Community collaboration levels are frankly staggering. While Microsoft has utilized its full engineering teams, including the Core CLR, Core Framework, ASP.NET, F# and Roslyn Compiler teams, working in the open on GitHub, more than 60 percent of pull requests approved for those repositories are coming from outside of Microsoft. The core project teams remain heavily focused on being responsive to those pull requests, often responding in a matter of minutes.

More important, however, is the passion of the volunteers in the .NET community that is driving the success of those projects. Until now, the .NET Foundation Board of Directors has relied on a team effort to manage the organization. But with the scale of activity that we have seen in the last year, it is time to bring someone to the team who can be fully dedicated to ensuring the rapid growth and continued innovation of the .NET open source ecosystem. I’m thrilled to have Martin onboard to do just that.

Please join me in welcoming our new executive director, Martin Woodward, to the .NET Foundation team and community!

 

Jay Schmelzer
President, .NET Foundation
Director Program Management, Microsoft

Announcing LLILC – A new LLVM-based Compiler for .NET

The .NET Foundation was set up to foster open source innovation and collaboration around .NET and so I’m very pleased to announce that we have released an initial version of a new project called LLILC (pronounced “lilac”) on GitHub. This is a new LLVM-based native code compiler for .NET Core which is being contributed to the .NET Foundation by Microsoft. LLVM is a very popular open source compiler framework which supports targeting multiple CPU types. LLILC creates a bridge into LLVM for .NET, making LLVM’s broad chip support and tools available to .NET Core.

We are envisioning using the LLVM infrastructure for a number of scenarios. The first tool in LLILC is a Just in Time(JIT) compiler for CoreCLR.

Why a new JIT for CoreCLR?

While the CoreCLR already has JIT, we saw an opportunity to provide a new code generator that has the potential to run across all the targets and platforms supported by LLVM. To enable this, as part of the LLILC project we’re opening a CIL reader that operates directly against the same common JIT interface as the production JIT (RyuJIT). This new JIT will allow any C# program written for the .NET Core class libraries to run on any platform that CoreCLR can be ported to and that LLVM will target.

There are several ongoing efforts to compile MSIL in the LLVM community. Why build another one?

When we started thinking about the fastest way to get a LLVM based code generation working we looked around at the current open source projects (SharpLang is a very cool one and LLVMSharp is also good) as well as code Microsoft had internally. While a number of the OSS projects already targeted LLVM BitCode, no one had anything yet that was a close match for the new CoreCLR interface. Looking at the options it was quickest for us to refactor and modify a working MSIL reader to target BitCode then get an existing project to support the contracts and APIs the CoreCLR uses for JIT’ing MSIL. Using an existing MSIL reader let us get the project bootsrapped using a number of building-block components that we think the wider community will also be able to take advantage of. This rapid bootstrap for C# across multiple platforms was the idea that was the genesis of this project and the compelling reason to start a new effort. We hope LLILC will provide a useful example – and a set of reusable components – for the whole community and make it easier for lots of other projects to interoperate with the CoreCLR runtime.

Why LLVM?

Basically LLVM is awesome. It’s already got great support across many platforms and chipsets and the community is amazingly active. The ability for LLVM to operate as both a JIT and as an AOT compiler was especially attractive. By bringing MSIL semantics to LLVM we plan to construct a number of tools that can work against CoreCLR or some sub set of its components. By putting all this out in an early state, we also hope folks will be able to produce tools and technologies that we haven’t even thought of yet.

Roadmap

As we said, it’s early days for the LLILC project but the current plan is to start with a classic JIT, then move to Install-time JIT (what we talk of as “NGen” in the .NET world). Next the LLILC project team want to look at an Ahead of Time compiler (AOT) – a build lab compiler that produces standalone native executables for many platforms, using some shared components from CoreCLR. The AOT compiler could also be used to improve startup time for important command line applications like the Roslyn Compiler.

The LLIC JIT will be a functionally correct and complete JIT for the CoreCLR runtime and a great reference implementation. It’s too early to say but it may not have sufficient throughput to be a first-tier JIT, but it is expected to produce high-quality code and so might make a very interesting second-tier or later JIT, or a good vehicle for prototyping codegen changes to feed back into RyuJIT.

Right now the core LLILC project team have been focusing on Windows along with Linux and Mac OS X but we would be very keen on folks getting involved that wanted to widen th platform base.

Current Status

Today on Windows we have the MSIL reader & LLVM JIT implemented well enough to compile a significant number of methods in the JIT bring up the tests included in CoreCLR. In these tests we compile about half the methods and then fall back to RyuJIT for cases we can’t handle yet. The testing experience is pretty decent for developers. The tests we run can be seen in the CoreCLR test repo. All tests run against the CoreCLR GC in conservative mode – which scans the frame for roots – rather than precise mode. We don’t yet support Exception Handling.

We’ve established builds on Linux and Mac OSX and are pulling together mscorlib, the base .NET Core library from CoreFx, and test asset dependencies to get testing off-the-ground for those platforms.

The LLILC team are starting to engage with the very cool folks in the LLVM community on the project (see the LLVM blog post) but we also hope that developers and academics who are familiar with LLVM will also get involved, helping C# and the other .NET languages be supported for LLVM.

The LLILC team will be working in the LLILC and LLVM repos over the next several months. They will be posting to the Forums as they make progress. As .NET Core becomes more fully supported on Linux and OS X, it is their intention to provide an LLILC implementation at a similar quality, so that you can use both projects together. It is also a great opportunity for us to get feedback, since we expect a lot of experimentation with .NET Core.

While it is early days, we’d love to have you join in and help bring the potential that LLILC offers to .NET Core via LLVM a reality. We want to know about your experience, either positive or issues that you encounter. If you have LLVM experience or want to gain that experience by working on the project, please do engage directly with the LLILC project. The team will actively be monitoring for any PRs, responding to issues and wanting to discuss any changes we are proposing to LLVM to help it support .NET.

LLVM and .NET are an interesting combination. .NET provides multiple-language support via a common language runtime, while LLVM supports “compilation of arbitrary programming languages” to multiple CPU targets. By combining these two worlds, LLILC provides a promising path to multiple platform support for .NET languages and by extension to the .NET developers across the globe. Exciting stuff.

Martin Woodward
Executive Director, .NET Foundation

Channel 9 Interview: .NET Open Source Initiative

At BUILD some of the .NET Foundation team members were interviewed on Channel 9.

Check out the interview here: .NET Open Source Initiative

Jay Schmelzer, Immo Landwerth, Martin Woodward and I chatted about what the .NET Foundation is, why we need it, and what it can do for the .NET ecosystem. Jay is the President of the .NET Foundation, Immo is on the Advisory Council and project lead for CoreFx and Martin is the Executive Director of the .NET Foundation. I’m officially the Secretary but I rather call myself Technical Evangelist :-).

Meet the rest of the people behind the .NET Foundation and join the conversations in our forums.

Enjoy,

Beth Massi, Technical Evangelist .NET Foundation

WCF Client is Open Source

We’re excited to announce a new open source project on GitHub from the WCF team at Microsoft.  This new version of WCF targets .NET Core and has been donated to the family of .NET Foundation open source projects.

Check out the WCF project for more details. The team is actively developing WCF in this repository, and they will review any issues and pull requests you wish to contribute. The wiki describes how to build and contribute to the project.

WCF targets the .NET Core framework which is designed to support multiple computer architectures and to run cross-platform. Right now the WCF project builds on Windows, but .NET Core offers the potential for it to run on OS X and Linux. The WCF team are working hard to make this a reality and to keep up to date as platform support for .NET Core grows, but if you want to help I know they would love contributions especially around improving and testing the platform support.

In this guest post from Ron Cain, he explains more about the new project and how to get started with the new, open source WCF and .NET Core.

— Martin

What is in the new WCF GitHub repository

The WCF repository contains a subset of the full Windows Communication Foundation product available on the Windows desktop, and it supports the library profiles already available for building WCF apps for the Windows Store.  These profiles are primarily client-based, making them suited for mobile devices or on mid-tier servers to communicate with existing WCF services.  The corresponding Windows Store libraries now available in this repository are:

ServiceModel.Primitives
ServiceModel.Http
ServiceModel.NetTcp
ServiceModel.Duplex
ServiceModel.Security

Features known to work

This project is under active development, but as we’ve learned from other projects we want WCF to become an open source project early in its lifecycle so that it has time to respond to community feedback before it is declared “done”.  This means some areas are a work in progress and you will see them changing rapidly. Our team’s goal is to achieve feature parity with the existing Windows Store profiles first and then improve as feedback comes in.  The following features are expected to work today:

Bindings:

BasicHttpBinding
NetHttpBinding
NetTcpBinding
CustomBinding

Transport-level binding elements:

HttpTransportBindingElement
TcpTransportBindingElement

Message encoding binding elements:

TextMessageEncodingBindingElement
BinaryMessageEncodingBindingElement

Channel shapes

IRequestChannel

Miscellaneous:

ChannelFactory<T>
ClientBase<T>
FaultContract, FaultException and FaultException<T>
MessageContract
DataContract serialization of simple and complex types
XmlSerializer serialization of simple and complex types (XmlSerializerFormatAttribute)
IClientMessageInspector

Known issues

Features that are available for Windows Store profiles but not fully enabled yet by WCF will throw a PlatformNotSupportedException today. Our team is actively working on these and expects to enable most of them soon.  Checkout the WCF Issues to see how our team is prioritizing this work, and feel free to comment on the issues for the features most important to you. The features not yet enabled are:

Duplex communication
WebSockets
SSL
Message level security
Digest or NTLM authentication
Streamed transfer mode
ETW tracing support
TCP transport level security

Visual Studio 2015 RC and WCF

Microsoft released Visual Studio 2015 RC at the Build conference in April 2015, and it supports the ability to use WCF in both Universal Windows and ASP.NET 5 applications.  The code used to build these WCF libraries used by VS 2015 RC was moved into this new GitHub repository, and the GitHub version will be the source used moving forward.  By contributing to the WCF project you will be contributing directly to the WCF capabilities available to Universal Windows and ASP.NET 5 apps.

Ron Cain, Project Lead, WCF.

Meet Your Advisory Council – Shaun Walker

Hi, I’m Beth Massi and I’m a Technical Evangelist for the .NET Foundation and also a member of the .NET team at Microsoft. I’m responsible for a lot of the team’s community efforts including event planning, content creation, customer outreach, as well as helping the .NET Foundation Board, Executive Director, and Advisory Council with .NET open source software initiatives.

The Advisory Council is composed of OSS project leaders that care deeply about .NET and the success of the foundation. They drive key initiatives in the foundation and guide the board. Learn more about what the Advisory Council is all about and participate in public discussions with them on our forums. We thought you’d like to get to know the folks on our Advisory Council so I’m kicking off a series of written interviews with them.

For this first post, I interviewed Shaun Walker, the Advisory Council Chairman. Shaun has 20+ years professional experience in architecting and implementing large scale software solutions for private and public organizations. He is a Co-Founder & Former CTO of DNN Corp and the original creator and maintainer of DotNetNuke, a web application framework for ASP.NET which spawned the largest and most successful open source community project on the Microsoft platform. He has been a Microsoft MVP in ASP.NET since 2004. He is a frequent speaker at conferences and user groups and is a contributing author to a variety of technology focused publications.

Tell us a little bit about yourself. What’s your background? When did you start getting interested in programming?

In 1979, when I was 9 years old, my family relocated to Ashcroft, British Columbia, Canada, a tiny community in the south-central interior of British Columbia with a population of approximately 1500 people. We relocated with a goal to start a commercial vineyard. My grandfather had owned a vineyard in Kelowna and he had sold it with the idea that the hot arid climate in Ashcroft, combined with cheap abundant land, would be a perfect environment for him and his children to establish a large, successful vineyard.

My mother and father, grandparents, and two uncles bought approximately 200 acres of sagebrush-covered land about 30 minutes outside Ashcroft, an area known as Basque Siding that was only accessible by navigating 5 miles of unpaved roads. We each had our own 50-acre parcel of land but the family all worked together to establish the infrastructure to develop our vineyards. We installed power, irrigation systems, cleared land, and built houses. Then we planted seedling grapes, and grew alfalfa and other crops to provide some initial income, as a vineyard takes five years before it reaches full production. We were extremely self-sufficient and raised our own cows, pigs, turkeys, and chickens, as well as our own fruits and vegetables.

When I was 12 years old we visited my cousins in Kelowna and I was introduced to the Commodore VIC-20 for the first time. My cousins were using it to play games but my parents clearly saw my fascination in this little machine. Money was scarce, so I am not sure what ultimately motivated their decision, but they decided to purchase a base model VIC-20, which came with an integrated keyboard, a cassette tape drive, and a user manual. They also had one stipulation — the only games I could play were games I created myself.

So I spent a lot of time typing BASIC code into the computer and storing the programs on cassette tape. My parents got me a subscription to COMPUTE! magazine, which provided source code listings for more advanced games. Pretty soon I started to recognize the patterns and techniques required to write programs, and I started building my own applications. Living on a remote farm created a perfect environment for investing myself in computers, as there were few distractions — I was either outside working in the vineyard ( pruning, weeding, picking, cultivating ) or I was inside the house typing code. My two younger brothers were more than happy to play the games that I created for them.

When I saw the movie War Games in 1983 starring Mathew Broderick, I really got excited about the potential of computers as more than just a standalone device. In the movie, the character played by Broderick hacks into the NORAD super computer nicknamed “Joshua” using a backdoor password and mistakenly invokes Global Thermonuclear War. In the climax, the supercomputer is tricked into playing Tic-Tac-Toe against itself until it reaches a draw and declares that “the only winning move is not to play.” After watching this movie numerous times I was convinced that I wanted to be a “hacker” and I sent off handwritten letters to many of the vendors listed in COMPUTE! magazine asking how I could become a programmer.

In the summer of 1983 we took a long road trip to Disneyland in California and spent some time visiting my uncle in the Bay Area. During this trip my parents finally caved in to my demands for a computer upgrade. The Commodore 64 was a large enhancement over the VIC-20, and we were able to get a good deal on a Commodore 64 package, a 1702 color monitor, and a 1541 floppy disk drive. I could not wait to get home and plug in these amazing new devices.

The following winter my family suffered a significant setback. Some exceptionally cold weather killed all of our grape plants, which ended my parents’ dream of operating a large commercial vineyard. They did not have the resources to replant the vineyard, so they both had to work traditional jobs while continuing to operate the farm by selling fruits and vegetables to the local markets to try and make ends meet. This was very hard work, and without any opportunity for vacations as the farm demanded the family’s full attention almost year round. The entire family pitched in to keep the farm afloat as my parents tried valiantly to preserve their investment.  

When I reached high school I was allowed to participate in an accelerated learning program that allowed me to take Computer Science courses that were two grade levels higher than my current grade. This exposed me to IBM PCs and Apple II computers and some new programming languages. I loved the challenge of solving problems and got a lot of satisfaction out of being able to tell the computer to follow my specific instructions. I had found my passion and I knew at that point that my future career would involve software development.

What initiatives are you working on (or passionate about) within the .NET Foundation?

As the Chairman of the Advisory Council, I am working closely with the Executive Director to provide a solid operating model for the .NET Foundation. I authored the original Charter for the Advisory Council and I am actively involved in formalizing project governance criteria.

Can you tell us some of the first open source projects you worked on as a contributor? Why did you get involved? How did you get started?

On Christmas Eve 2002 I released the first version of DotNetNuke, an open source .NET CMS Platform. DotNetNuke was based on a sample application that Microsoft had released for ASP.NET 1.0 called the IBuySpy Portal. I had significantly enhanced the original sample application with many additional capabilities including multi-tenancy, and felt compelled to share it with the broader ASP.NET community. Releasing DotNetNuke as an MIT-licensed open source project allowed it to gain worldwide recognition and adoption.

Looking back, what bug are you most proud of fixing in an open source project?

There were many bugs that I fixed on the DotNetNuke project, but the one which is most memorable for me was a security vulnerability in an early version of the platform which allowed a user to upload executable code files. The actual code fix turned out to be trivial, but understanding how the exploit was being orchestrated was far more challenging. Ultimately it was leveraging a combination of an improper string validation in the application as well as an obscure legacy behavior in IIS. I had to use my powers of persuasion to convince the Iranian hacker who discovered the vulnerability to explain the process he was using to exploit the loophole. And then I had to determine the appropriate safeguard, patch the application, and inform the community of the vulnerability.

What project(s) do you spend most of your time on now?

I still write open source extensions for DotNetNuke, but I am also working in stealth mode on a new open source project that I expect to release later this year… stay tuned.

Can you tell us one thing you have learned about running an open source project?

One of the most important things to understand about running an open source project is that developers are driven by personal motivation. As a result, management in an open source project is not so much about directing people what to do, but rather figuring out how to take best advantage of all of the random contributions from the community.

Why is open source software important to you?

Open source software allows people of modest backgrounds, education, business experience, culture, and financial resources to overcome adversity, unleash their creativity and passion, and pursue success in the areas of philanthropy or entrepreneurship.

What is it about .NET that you like most?

I like that .NET is a constantly evolving and integrated suite of technologies that allow software developers to solve complex business problems.

What does the future of .NET look like in your dreams?

In my dreams, .NET becomes an even more dominant technology platform than it is today. It will evolve in a transparent manner to embrace open standards and trends and will continue to incorporate modern characteristics which allow it to remain relevant and competitive in the broader technology landscape.

Thanks, Shaun!

Feel free to ask more interview questions in the comments below.

Enjoy,
-Beth Massi, .NET Community

Meet Your Advisory Council – Phil Haack

Last week I kicked off a series of written interviews with our .NET Foundation Advisory Council members. The Advisory Council is composed of OSS project leaders that care deeply about .NET and the success of the foundation. They drive key initiatives in the foundation and guide the board. Learn more about what the Advisory Council is all about and participate in public discussions with them on our forums.

For this next post, I interviewed Phil Haack. Phil works at GitHub as an Engineering Manager for the Desktop team. This team is responsible for GitHub for Mac, GitHub for Window, and the GitHub Extension for Visual Studio. Prior to GitHub, he was a Senior Program Manager at Microsoft responsible for shipping ASP.NET MVC and NuGet. These projects were released under open source licenses and helped serve as examples to other teams for how to ship open source software. He regularly writes for his blog http://haacked.com/ and tweets random observations on Twitter as @haacked. He also speaks at conferences here and there, and has quit writing technical books forever, several times now.

Tell us a little bit about yourself. What’s your background? When did you start getting interested in programming?

My last name is pronounced “hack” which pretty much guaranteed my involvement in computers and programming. I was interested in programming at a young age when my Dad bought a TRS-80 Color Computer and we’d spend hours typing in code listings from Byte magazine. Most of my programming around this time was making the computer draw pictures and creating Mad Lib style programs. I didn’t seriously get into programming until after college when I took a job as a programmer as a way to pay the bills for a bit before I applied to grad schools for mathematics. I never got around to those applications.

What initiatives are you working on (or passionate about) within the .NET Foundation?

I’m passionate about helping OSS maintainers become better maintainers.

What’s the biggest piece of advice you can give to maintainers to become better?

There’s so much I could say, but if I had one thing to say, it’s be empathetic. Sometimes the open source culture tries to completely take the human element out of the work we do under the fallacy that the compiler and computer doesn’t care about social issues. But the fact is that software is written for humans. Humans have to care and tend to the code. Humans use the end product of the code. Without humans, there’s no need for the code in the first place.

There’s often a lot of fatigue when working with new people joining OSS. I understand it. It’s frustrating to be asked the same question for the 100th time because people didn’t read the README. But losing your cool and blowing up at people is a losing proposition. For many of these folks, their interaction with you might be their very first interaction with Open Source ever! Your response could lead them down a road to becoming a valued and experienced contributor, or could totally cool them off the idea of joining in. So be welcoming. Try to remember how nervous people are about making their first contribution and act accordingly.

Can you tell us some of the first open source projects you worked on as a contributor? Why did you get involved? How did you get started?

Like many OSS contributors, I got involved because I was bored. At work I spent all day writing the same standard data-in data-out web applications for every client. Of course when I updated my resume, I managed to make those applications sound cutting edge and full of rocket surgery. Open Source afforded me the opportunity to delve into different types of software. For example, I wanted to try my hand at a desktop application. I spent a lot of time at work reading blog entries from people doing more interesting work than I was doing.

So it’s fitting that my first foray with open source started with RSS Bandit (an RSS aggregator) a long time ago. For the youngsters reading this, it’s like decentralized Medium full of very self-important writing (again, like Medium), but with many gems hidden among the bloviating. I started off by making contributions to the documentation. The maintainers started to trust me and gave me commit access so I could make direct contributions. It was a thrill to see my contributions used in the wild. I was hooked.

From there I started my own project with Subtext which pretty much amounted to taking a second job. It was with great sadness and relief that I shut it down after some 8 years working on it. It’s been supplanted by Jekyll for me. It’s the cycle of code. Newer and better code replaces older outdated approaches.

Looking back, what bug are you most proud of fixing in an open source project?

Too many to consider. Perhaps it was taking the four configuration files and merging them into one (via Subtext) that really simplified the installation of the blog engine. That really drilled into me the idea that usability is one of the most essential features for any project. The installation process needs to be flawless. If people can’t even get started using your software, they won’t stick around. They really don’t care about how hard that work is for you. They don’t have time to think about you, they’re just trying to get something done and the best thing you can do is make sure your software doesn’t get in their way.

What project(s) do you spend most of your time on now?

In terms of Open Source projects, I mostly spend my time on Octokit.net, a client library for the GitHub API I also occasionally maintain the many small NuGet packages I’ve written. I also maintain the Semantic Versioning (semver) specification. But that’s mostly a hands-off affair these days since a great feature of a specification like that is to not change too drastically too often. Rather than focus my time on one project these days, I mostly contribute small fixes back to a large number of other open source projects that we happen to use at work and that I use in my free time.

Can you tell us one thing you have learned about running an open source project?

A lot of people will tell you they’ll contribute, but very few will. So treat those folks very well! Well, treat everybody well! Also, everybody has opinions on what you should do. After all, opinions are free. So seek out opinions from those who have skin in the game. The idea that if you implement some feature, someone will start using your code is usually a lie. So I tend to focus on those who are actually using the software. I also focus on those who go so far as to contribute to the software in any way. When you consider that the default action for a vast majority of users is to do nothing, something as seemingly small as logging an issue is a major contribution. Appreciate it!

Why is open source software important to you?

It’s mostly about the community of folks who have a shared interest around a piece of code and work together to raise the state of the art. As a consumer, it’s important to me to be able to tweak things for my scenarios at times when the API lacks the flexibility to accomplish my goals without code changes. As a participant, it’s been a great source of professional and skill growth. OSS has been a great outlet to leveling up and diversifying my skills. The types of projects I can work on isn’t driven solely by what the market finds profitable at any given moment.

What is it about .NET that you like most?

I’m just a big fan of C# and Visual Studio. I happen to like statically typed languages and am really familiar with C#. I think platforms are a lot like culture. You tend to like the one you’re born into. My first job happened to use classic ASP and I’ve been on the Microsoft stack ever since. Though being at GitHub has definitely helped me branch out a lot more. There’s so much each community can learn from each other.

What does the future of .NET look like in your dreams?

In my dreams, everybody who uses .NET is doing it on GitHub on every platform!

Thanks, Phil!

Feel free to ask more interview questions in the comments below.

Enjoy,
Beth Massi, .NET Foundation Technical Evangelist