Ubuntu is distributed on two types of images described below.

Desktop image
The desktop image allows you to try Ubuntu without changing your computer at all, and at your option to install it permanently later. This type of image is what most people will want to use. You will need at least 384MiB of RAM to install from this image.

Server install image
The server install image allows you to install Ubuntu permanently on a computer for use as a server. It will not install a graphical user interface. 

 This effectively means that what looks like a very large chunk of .NET is now open source

Immutability comes with a lot of benefits, but sometimes it can be a bit cumbersome to deal with when you only want to update some properties. Since the object is immutable, you need to create a copy with all the existing values and the new updated one.

I will show you how Records in C# 9 will greatly simplify this

• We improved solution load performance by optimizing design time build.
• We've added installation progress details on Visual Studio Installer.
• You can pause your installation and resume at a later time.
• We streamlined the update process so the notification takes you directly to the Installer.
• Non-administrators can create a VS layout.
• We added a new shortcut for Edit.Duplicate in the keyboard mapping.
• We made significant improvements to the F# language and tools, particularly for .NET Core SDK projects.
• The C++ compiler optimizes your code to run faster through improved optimizations.
• C++ Mapfile generation overhead is reduced in full linking scenarios.
• Debug options are available for Embedded ARM GCC support.
• We added strong name signing on CoreCLR for the C# compiler.
• Visual Studio Tools for Xamarin has lots of new productivity updates for iOS and Android developers.
• Python no longer requires a completion DB, and Anaconda users have support for conda.
• The Performance Profiler's CPU Usage Tool can display logical call stacks for asynchronous code.
• The CPU Usage tool displays source line highlighting and async/await code with logical 'Call Stack Stitching'.
• The debugger supports thread names set via SetThreadDescription APIs in dump debugging.
• Snapshot Debugging can be started from the Debug Target dropdown for ASP.NET applications.
• We've launched the initial implementation of Navigate to decompiled sources for .NET code navigation.
• New enhancements for Configure Continuous Delivery include support for TFVC, Git authentication over SSH, and containerized projects.
• You can now click on the Continuous Delivery tile in Team Explorer to configure automated build and deployments for your application.
• Team Explorer supports Git tags and checking out pull request branches.
• Service Fabric Tooling for the 6.1 Service Fabric release is now available.
• The Windows 10 Insider Preview SDK can be installed as an optional component.
• File versions for a number of Visual Studio executables now reflect the minor release.
• Test Explorer has a hierarchy view and real time test discovery is now on by default.
• We have added support for testing Win10 IoT Core applications.
• Visual Studio Build Tools supports TypeScript and Node.js.
• ClickOnce Tools support signing application and deployment manifests with CNG certificate.
• You can access Azure resources such as Key Vault using your Visual Studio accounts. 

As anyone in the .NET community who hasn't been living under a rock will know, there's a lot of exciting things happening with .NET at the moment with the announcement of the open source, cross platform, .NET Core. However, partly due to the very open nature of its evolution, there's been a whole host of names associated with its development - vNext, ASP.NET 5, ASP.NET Core, .NET generations etc.

In this post I'm going to try and clarify some of the naming and terminology surrounding the evolution of the .NET framework. I'll discuss some of the challenges the latest iteration is attempting to deal with and how the latest developments aim to address these.

This is really for those that have seen some of the big announcements but aren't sure about the intricacies of this new framework and how it relates to the existing ecosystem, which was my situation before I really started digging into it all properly!

Hopefully by the end of this article you'll have a clearer grasp of the latest in .NET! 

namespace OpenAPISwaggerDoc.Web.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ConventionTestsController : ControllerBase
    {
        // GET: api/ConventionTests/5
        [HttpGet("{id}", Name = "Get")]
        [ApiConventionMethod(typeof(DefaultApiConventions), nameof(DefaultApiConventions.Get))]
        public string Get(int id)
        {
            return "value";
        }

using Microsoft.AspNetCore.Mvc.ApiExplorer;

namespace Microsoft.AspNetCore.Mvc
{
    public static class DefaultApiConventions
    {
        [ApiConventionNameMatch(ApiConventionNameMatchBehavior.Prefix)]
        [ProducesDefaultResponseType]
        [ProducesResponseType(200)]
        [ProducesResponseType(404)]
        public static void Get(
[ApiConventionNameMatch(ApiConventionNameMatchBehavior.Suffix)]
[ApiConventionTypeMatch(ApiConventionTypeMatchBehavior.Any)] 
object id);
    }
}

namespace OpenAPISwaggerDoc.Web.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    [ApiConventionType(typeof(DefaultApiConventions))]
    public class ConventionTestsController : ControllerBase

[assembly: ApiConventionType(typeof(DefaultApiConventions))]
namespace OpenAPISwaggerDoc.Web
{
    public class Startup

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ApiExplorer;

namespace OpenAPISwaggerDoc.Web.AppConventions
{
    public static class CustomConventions
    {
        [ProducesDefaultResponseType]
        [ProducesResponseType(StatusCodes.Status201Created)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ApiConventionNameMatch(ApiConventionNameMatchBehavior.Prefix)]
        public static void Insert(
            [ApiConventionNameMatch(ApiConventionNameMatchBehavior.Any)]
            [ApiConventionTypeMatch(ApiConventionTypeMatchBehavior.Any)]
            object model)
        { }
    }
}

namespace OpenAPISwaggerDoc.Web.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ConventionTestsController : ControllerBase
    {
        [HttpPost]
        [ApiConventionMethod(typeof(CustomConventions), nameof(CustomConventions.Insert))]
        public void Insert([FromBody] string value)
        {
        }

namespace OpenAPISwaggerDoc.Web.Controllers
{
    [Produces("application/json")]
    [Route("api/authors/{authorId}/books")]
    [ApiController]
    public class BooksController : ControllerBase

namespace OpenAPISwaggerDoc.Web
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(setupAction =>
            {
                setupAction.OutputFormatters.Add(new XmlSerializerOutputFormatter());

namespace OpenAPISwaggerDoc.Web.Controllers
{
    [Produces("application/json", "application/xml")]
    [Route("api/authors/{authorId}/books")]
    [ApiController]
    public class BooksController : ControllerBase

namespace OpenAPISwaggerDoc.Web
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(setupAction =>
            {
                setupAction.ReturnHttpNotAcceptable = true; // Status406NotAcceptable

namespace OpenAPISwaggerDoc.Web.Controllers
{
    [Produces("application/json", "application/xml")]
    [Route("api/authors/{authorId}/books")]
    [ApiController]
    public class BooksController : ControllerBase
    {
        /// <summary>
        /// Create a book for a specific author
        /// </summary>
        /// <param name="authorId">The id of the book author</param>
        /// <param name="bookForCreation">The book to create</param>
        /// <returns>An ActionResult of type Book</returns>
        [HttpPost()]
        [Consumes("application/json")]
        [ProducesResponseType(StatusCodes.Status201Created)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult<Book>> CreateBook(
            Guid authorId,
            [FromBody] BookForCreation bookForCreation)
        {

Issues Fixed in 15.9.21

• Fixed a bug where the .NET Profiling tools couldn't be installed on non-enterprise versions of Visual Studio 2017 when using an offline installer.
• Fixed C++ compiler bug where a static_cast in a decltype would evaluate incorrectly. To minimize disruptions to existing codebases, in VS2017 this fix takes effect when the (newly added) /d1decltypeIdentityConversion switch is thrown.
• New Spectre mitigation options in C++ compiler: /Qspectre-load & /Qspectre-load-cf for speculative load hardening.

Security Advisory Notices

• Diagnostics Hub Standard Collector Service Elevation of Privilege Vulnerability
• A spoofing vulnerability exists when creating an Outlook Web-Addin if multi-factor authentication is enabled