From ff57fcccfe2341e7e73ea636098f91e2c1b1e7dd Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Wed, 4 Nov 2020 20:04:08 -0800 Subject: [PATCH 1/7] Update glossary --- docs/project/glossary.md | 201 ++++++++++++--------------------------- 1 file changed, 60 insertions(+), 141 deletions(-) diff --git a/docs/project/glossary.md b/docs/project/glossary.md index c1b6b687354b8..5fd2c4113e4ad 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -14,9 +14,11 @@ terminology. | AOT | Ahead-of-time compiler. Converts the MSIL bytecode to native machine code for a specific target CPU architecture. | | BBT | Microsoft internal early version of C/C++ PGO. See https://www.microsoft.com/windows/cse/bit_projects.mspx. | | BOTR | Book Of The Runtime. | +| BCL | Base Class Library. A set of `System.*` (and to a limited extent `Microsoft.*`) libraries that make up the lower layer of the .NET library stack. | | CLR | Common Language Runtime. | | COMPlus | An early name for the .NET platform, back when it was envisioned as a successor to the COM platform (hence, "COM+"). Used in various places in the CLR infrastructure, most prominently as a common prefix for the names of internal configuration settings. Note that this is different from the product that eventually ended up being named [COM+](https://msdn.microsoft.com/en-us/library/windows/desktop/ms685978.aspx). | | COR | [Common Object Runtime](http://www.danielmoth.com/Blog/mscorlibdll.aspx). The name of .NET before it was named .NET. | +| CoreFX | Core Framework. Original roject name for open source and cross-platform version of [.NET runtime libraries](https://github.com/dotnet/runtime/tree/master/src/libraries) | | DAC | Data Access Component. An abstraction layer over the internal structures in the runtime. | | EE | Execution Engine. | | GC | [Garbage Collector](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/garbage-collection.md). | @@ -71,29 +73,6 @@ In this document, the following terms are used: different implementations. For instance, our vector library relies on the JIT to use the highest available SIMD instruction set. -* **AOT**. Ahead of time compiler. Similar to JIT, this compiler also translates - IL to machine code. In contrast to JIT compilation, AOT compilation happens - before the application is executed and is usually performed on a different - machine. AOT tool chains don't trade runtime for compile time and thus can - spend more time optimizing. Since the context of AOT is the entire - application, the AOT compiler can also perform cross module linking and whole - program analysis, which means that all references are followed and a single - executable is produced. - -* **NGEN**. Native (image) generation. You can think of this technology as a - persistent JIT compiler. It usually compiles code on the machine where the - code will be executed, but compilation typically occurs at install time. - -* **CoreFX**. Core framework. Conceptually a set of `System.*` (and to a limited - extent `Microsoft.*`) libraries that make up the lower layer of the .NET - library stack. It's what most people would think of as the Base Class Library - (BCL). The BCL is a general purpose, lower level set of functionality that - higher-level frameworks, such as WCF and ASP.NET, build on. The source code of - the .NET Core library stack is contained in the [CoreFX repo][corefx]. - However, the majority of the .NET Core APIs are also available in the .NET - Framework, so you can think of CoreFX as a fork of the .NET Framework library - stack. - * **CLI**. Command Line Interface --or-- Common Language Infastructure. * Command Line Interface: A tool that has no graphical interface and is intended to be used completely from a console/terminal. Also is commonly @@ -103,114 +82,30 @@ In this document, the following terms are used: [ECMA-355][ECMA-355]. * **CLR**. Common Language Runtime: The runtime/environment that .NET code - executes in. Is also commonly used to refer to the Microsoft Windows only - implementation - -## Runtimes - -### Common Language Runtime - -**Also referred to as**: CLR, VM, runtime - -The CLR is a virtual machine, i.e. it includes the facilities to generate and -compile code on-the-fly using a JIT compiler. The existing Microsoft CLR -implementation is Windows only. + executes in. Is also commonly used to refer to the Microsoft .NET Framework + Windows only implementation. -### Core Common Language Runtime +## .NET Runtimes -**Also referred to as**: CoreCLR, VM, runtime +### .NET Core / .NET -It's built from the same code base as the CLR. Originally, CoreCLR was the -runtime of Silverlight and was designed to run on multiple platforms, -specifically Windows and OS X. CoreCLR is now part of .NET Core and represents a -simplified version of the CLR. It's still a [cross platform][core-build-status] -runtime. CoreCLR is also a virtual machine with a JIT. +.NET Core has been the name for the open source, cross-platform stack that +ASP.NET Core and UWP applications are built on. For more details, +read [this blog post][introducing-net-core]. -### Core Runtime - -**Also referred to as**: CoreRT - -In contrast to the CLR/CoreCLR, CoreRT is not a virtual machine, i.e. it doesn't -include the facilities to generate and run code on-the-fly because it doesn't -include a JIT. It does, however, include the GC and the ability for runtime type -identification (RTTI) as well as reflection. However, its type system is -designed so that metadata for reflection can be omitted. This enables having an -AOT tool chain that can link away superfluous metadata and (more importantly) -identify code that the application doesn't use. - -## Platforms +.NET Core has become future of the platform and we refer to it just as .NET today. +For more details, read [this blog post][introducing-net-5]. ### .NET Framework -**Also referred to as**: Desktop, full framework, in-box framework, ~~CLR~~ +**Also referred to as**: Desktop, full framework -This refers to the .NET Framework that first shipped in 2002 and has been -updated on a regular basis since then. It's the main framework folks target -today and allows you to build a wide variety of applications, such as WinForms, -WPF, ASP.NET, and command line tools. +.NET Framework was the very first .NET runtime. It first shipped in 2002 and it has been +updated on a regular basis since then. The .NET Framework was designed to run on Windows only. Some versions of the .NET Framework come pre-installed with Windows, some require to be installed. However, in both cases the .NET Framework is a system-wide component. -Applications do not include .NET Framework DLLs when deploying; the correct .NET -version must be on the machine. - -### .NET Core - -**Also referred to as**: UWP, ~~Store~~ - -Originally, .NET Core was the identifier we used to describe the .NET APIs -Windows 8 store applications could use. When we designed the API set, we wanted -to create a foundation for .NET where portability is a first class concern for -the layering and componentization. For more details, read [this blog -post][introducing-net-core]. - -Today, .NET Core is no longer just for store applications. .NET Core is the name -for the open source, cross-platform stack that ASP.NET Core and UWP applications -are built on. The stack includes a set of framework libraries (CoreFX), a JIT -based runtime (CoreCLR), an AOT based runtime (CoreRT), and a set of tooling -(such as the dotnet CLI). - -That's why referring to .NET Core as 'Store' is no longer correct. But you can -think of today's .NET Core as an evolution of the original APIs available for -store applications. Many of the original design goals are still relevant, -especially around layering and portability. - -### Universal Windows Platform (UWP) - -**Also referred to as**: Store, WinRT, Metro - -The Universal Windows Platform (UWP) is the platform that is used for building -modern, touch-enabled Windows applications as well as headless devices for -Internet of Things (IoT). It's designed to unify the different types of devices -that you may want to target, including PCs, tablets, phablets, phones, and even -the Xbox. - -UWP provides many services, such as a centralized app store, an execution -environment (AppContainer), and a set of Windows APIs to use instead of Win32 -(WinRT). UWP has no dependency on .NET; apps can be written in C++, C#, VB.NET, -and JavaScript. When using C# and VB.NET the .NET APIs are provided by .NET -Core. - -**Also referred to as**: ahead-of-time (AOT), IL compiler (ILC) - -.NET Native is a compiler tool chain that will produce native code ahead-of-time -(AOT), as opposed to just-in-time (JIT). The compilation can happen on the -developer machine as well as on the store side, which allows blending AOT with -the benefits of servicing. - -You can think of .NET Native as an evolution of NGEN (Native Image Generator): -NGEN basically simply runs the JIT up front, the code quality and behavior is -identical to the JITed version. Another downside of NGEN is that it happens on -the user's machine, rather than the developer's machine. NGEN is also at the -module level, i.e. for each MSIL assembly there is a corresponding NGEN'ed -assembly that contains the native code. .NET Native on the other hand is a C++ -like compiler and linker. It will remove unused code, spend more time optimizing -it, and produce a single, merged module that represents the closure of the -application. - -UWP was the first application model that was supported by .NET Native. We now -also support building native console applications for Windows, OS X and Linux. ### Rotor @@ -232,34 +127,58 @@ officially updated since .NET Framework 2.0. ### Mono -Mono is an open source alternative to the .NET Framework. Mono started around +[Mono][mono] is an open source alternative to the .NET Framework. Mono started around the same time the .NET Framework was first released. Since Microsoft didn't -release Rotor as open source, Mono was forced to start from scratch and is thus +release Rotor as open source, Mono was forced to start from scratch and was thus a complete re-implementation of the .NET Framework with no shared code. -When .NET Core was released under the MIT license, Microsoft also released large -chunks of the .NET Framework under the MIT license as well, which can be found -[here][referencesource]. This enabled the Mono community to use the same code -the .NET Framework uses in order to close gaps and avoid behavioral differences. +Today, the [Mono runtime](https://github.com/dotnet/runtime/tree/master/src/mono) is part +of unified .NET platform. It is optimized for mobile (e.g. Xamarin) and browser (e.g. Blazor) scenarios. + +### CoreCLR + +Originally, CoreCLR was the runtime of Silverlight and was designed to run on multiple +platforms, specifically Windows and OS X. + +Today, the [CoreCLR runtime](https://github.com/dotnet/runtime/tree/master/src/coreclr) +is part of unified .NET platform. It is optimized for cloud (e.g. ASP.NET) and +desktop (e.g. WinForms, WPF) scenarios. + +## Ahead-Of-Time Compilation (AOT) + +Most flavors of .NET runtime come with at least partial AOT compilation. Variety of AOT technologies +with unique characteristics were developed for .NET runtimes over the years. + +### ReadyToRun + +**Also referred to as**: R2R + +[ReadyToRun](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/readytorun-overview.md) +is a file format used by CoreCLR runtime to store AOT compiled code. `crossgen` is the AOT compiler that +produces binaries in the ReadyToRun file format. + +### NGen + +[NGen](https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator) +is AOT technology included in .NET Framework. It usually compiles code on the machine where +the code will be executed at install time. + +### Full AOT -Mono is primarily used to run .NET applications on Linux and macOS (though to -get into the Mac App Store you need Xamarin, see below). There are ports of Mono -to other platforms, see [Mono's Supported Platforms][mono-supported-platforms] +[Full AOT](https://docs.microsoft.com/en-us/xamarin/ios/internals/architecture) is used +by Mono runtime in environments that prohibit fallback to JIT. -Mono has implementations (though not necessarily complete) of WinForms, ASP.NET, -and System.Drawing. +### Hybrid AOT -### Xamarin +[Hybrid AOT](https://docs.microsoft.com/en-us/xamarin/mac/internals/aot#hybrid-aot) is used +by Mono runtime in environment that allow fallback to JIT. -Xamarin is a commercial offering for building mobile applications targeting -Android, iOS and Mac OS X Store. It's based on Mono, and on iOS and Android -surfaces a different API profile, called the mobile profile. The subsetting was -necessary to reduce the footprint, both by shipping smaller versions of the -system libraries as well as making them more linker friendly. While Mono runs on -macOS without Xamarin, their linker is required make the app package for the -Mac App Store. Xamarin ships a full static compiler on iOS, as the platform -does not support dynamic code generation. +### Native AOT +[Native AOT](https://github.com/dotnet/designs/blob/main/accepted/2020/form-factors.md#native-aot-form-factors) is +a .NET runtime form factor with key performance characteristics (startup time, binary size and steady state throughput) competitive +with statically compiled languages. .NET runtime flavor based on CoreCLR with these characteristics is being developed as +experimental project in [dotnet/runtimelab](https://github.com/dotnet/runtimelab/tree/feature/NativeAOT) repo. ## Frameworks @@ -346,8 +265,8 @@ and enabling support for running WPF on .NET Core (Windows Only). [introducing-net-core]: https://devblogs.microsoft.com/dotnet/introducing-net-core/ -[core-build-status]: https://github.com/dotnet/coreclr#build-status -[corefx]: http://github.com/dotnet/corefx +[introducing-net-5]: https://devblogs.microsoft.com/dotnet/introducing-net-5/ +[mono]: http://github.com/mono/mono [referencesource]: https://github.com/microsoft/referencesource [mono-supported-platforms]: http://www.mono-project.com/docs/about-mono/supported-platforms/ [mono-winforms]: http://www.mono-project.com/docs/gui/winforms/ From eba13c8948f566ce73a4273ec344d981b0228778 Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Wed, 4 Nov 2020 20:44:15 -0800 Subject: [PATCH 2/7] Update docs/project/glossary.md Co-authored-by: Juan Hoyos --- docs/project/glossary.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/project/glossary.md b/docs/project/glossary.md index 5fd2c4113e4ad..39e5186b1e9e9 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -18,7 +18,7 @@ terminology. | CLR | Common Language Runtime. | | COMPlus | An early name for the .NET platform, back when it was envisioned as a successor to the COM platform (hence, "COM+"). Used in various places in the CLR infrastructure, most prominently as a common prefix for the names of internal configuration settings. Note that this is different from the product that eventually ended up being named [COM+](https://msdn.microsoft.com/en-us/library/windows/desktop/ms685978.aspx). | | COR | [Common Object Runtime](http://www.danielmoth.com/Blog/mscorlibdll.aspx). The name of .NET before it was named .NET. | -| CoreFX | Core Framework. Original roject name for open source and cross-platform version of [.NET runtime libraries](https://github.com/dotnet/runtime/tree/master/src/libraries) | +| CoreFX | Core Framework. Original project name for open source and cross-platform version of [.NET runtime libraries](https://github.com/dotnet/runtime/tree/master/src/libraries) | | DAC | Data Access Component. An abstraction layer over the internal structures in the runtime. | | EE | Execution Engine. | | GC | [Garbage Collector](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/garbage-collection.md). | From bef7c81a464ee48f49c5761e651c6f048d5634ee Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Wed, 4 Nov 2020 20:45:55 -0800 Subject: [PATCH 3/7] Update docs/project/glossary.md Co-authored-by: Juan Hoyos --- docs/project/glossary.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/project/glossary.md b/docs/project/glossary.md index 39e5186b1e9e9..9d0267cd05b03 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -133,7 +133,7 @@ release Rotor as open source, Mono was forced to start from scratch and was thus a complete re-implementation of the .NET Framework with no shared code. Today, the [Mono runtime](https://github.com/dotnet/runtime/tree/master/src/mono) is part -of unified .NET platform. It is optimized for mobile (e.g. Xamarin) and browser (e.g. Blazor) scenarios. +of the unified .NET platform. It is optimized for mobile (e.g. Xamarin) and browser (e.g. Blazor) scenarios. ### CoreCLR From b4c19399a40887fb96b05bc29de4f4f5e0dfead1 Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Thu, 5 Nov 2020 07:10:06 -0800 Subject: [PATCH 4/7] Apply suggestions from code review Co-authored-by: Stephen Toub --- docs/project/glossary.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/project/glossary.md b/docs/project/glossary.md index 9d0267cd05b03..0d2d81d940e99 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -82,8 +82,8 @@ In this document, the following terms are used: [ECMA-355][ECMA-355]. * **CLR**. Common Language Runtime: The runtime/environment that .NET code - executes in. Is also commonly used to refer to the Microsoft .NET Framework - Windows only implementation. + executes in. It is also commonly used to refer to the Microsoft .NET Framework + Windows-only implementation. ## .NET Runtimes @@ -93,14 +93,14 @@ In this document, the following terms are used: ASP.NET Core and UWP applications are built on. For more details, read [this blog post][introducing-net-core]. -.NET Core has become future of the platform and we refer to it just as .NET today. +.NET Core has become future of the platform, and we refer to it just as .NET today. For more details, read [this blog post][introducing-net-5]. ### .NET Framework **Also referred to as**: Desktop, full framework -.NET Framework was the very first .NET runtime. It first shipped in 2002 and it has been +.NET Framework was the very first .NET runtime. It first shipped in 2002, and it has been updated on a regular basis since then. The .NET Framework was designed to run on Windows only. Some versions of the @@ -146,7 +146,7 @@ desktop (e.g. WinForms, WPF) scenarios. ## Ahead-Of-Time Compilation (AOT) -Most flavors of .NET runtime come with at least partial AOT compilation. Variety of AOT technologies +Most flavors of .NET runtime come with at least partial AOT compilation. A variety of AOT technologies with unique characteristics were developed for .NET runtimes over the years. ### ReadyToRun @@ -154,14 +154,14 @@ with unique characteristics were developed for .NET runtimes over the years. **Also referred to as**: R2R [ReadyToRun](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/readytorun-overview.md) -is a file format used by CoreCLR runtime to store AOT compiled code. `crossgen` is the AOT compiler that +is a file format used by the CoreCLR runtime to store AOT compiled code. `crossgen` is the AOT compiler that produces binaries in the ReadyToRun file format. ### NGen [NGen](https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator) -is AOT technology included in .NET Framework. It usually compiles code on the machine where -the code will be executed at install time. +is AOT technology included in .NET Framework. It usually compiles code at install time on the machine where +the code will be executed. ### Full AOT @@ -177,7 +177,7 @@ by Mono runtime in environment that allow fallback to JIT. [Native AOT](https://github.com/dotnet/designs/blob/main/accepted/2020/form-factors.md#native-aot-form-factors) is a .NET runtime form factor with key performance characteristics (startup time, binary size and steady state throughput) competitive -with statically compiled languages. .NET runtime flavor based on CoreCLR with these characteristics is being developed as +with statically compiled languages. A .NET runtime flavor based on CoreCLR with these characteristics is being developed as experimental project in [dotnet/runtimelab](https://github.com/dotnet/runtimelab/tree/feature/NativeAOT) repo. ## Frameworks From 761a111c3fb2dd7272d32270830e471117f16812 Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Thu, 5 Nov 2020 07:10:58 -0800 Subject: [PATCH 5/7] Update docs/project/glossary.md --- docs/project/glossary.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/project/glossary.md b/docs/project/glossary.md index 0d2d81d940e99..c02ae89795d93 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -171,7 +171,7 @@ by Mono runtime in environments that prohibit fallback to JIT. ### Hybrid AOT [Hybrid AOT](https://docs.microsoft.com/en-us/xamarin/mac/internals/aot#hybrid-aot) is used -by Mono runtime in environment that allow fallback to JIT. +by Mono runtime in environments that allow fallback to JIT. ### Native AOT From d8a197afbb6a369ea51944871da83a23157c4585 Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Thu, 5 Nov 2020 07:22:20 -0800 Subject: [PATCH 6/7] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Günther Foidl --- docs/project/glossary.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/project/glossary.md b/docs/project/glossary.md index c02ae89795d93..c332af4b06cca 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -91,10 +91,10 @@ In this document, the following terms are used: .NET Core has been the name for the open source, cross-platform stack that ASP.NET Core and UWP applications are built on. For more details, -read [this blog post][introducing-net-core]. +read [Introducing .NET Core][introducing-net-core]. .NET Core has become future of the platform, and we refer to it just as .NET today. -For more details, read [this blog post][introducing-net-5]. +For more details, read [Introducing .NET 5][introducing-net-5]. ### .NET Framework From 1a5bd1cc3f3ed7e3d7406a2d0d3faa207601ff82 Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Thu, 5 Nov 2020 08:13:02 -0800 Subject: [PATCH 7/7] Feedback --- docs/project/glossary.md | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/docs/project/glossary.md b/docs/project/glossary.md index c332af4b06cca..b36f0eaf4cdf0 100644 --- a/docs/project/glossary.md +++ b/docs/project/glossary.md @@ -132,9 +132,12 @@ the same time the .NET Framework was first released. Since Microsoft didn't release Rotor as open source, Mono was forced to start from scratch and was thus a complete re-implementation of the .NET Framework with no shared code. -Today, the [Mono runtime](https://github.com/dotnet/runtime/tree/master/src/mono) is part +Today, the [Mono VM](https://github.com/dotnet/runtime/tree/master/src/mono) is part of the unified .NET platform. It is optimized for mobile (e.g. Xamarin) and browser (e.g. Blazor) scenarios. +"C# powered by Mono" has been scripting engine of choice for a number of game engines. +Unity - the world's most popular game engine - is scripted by C#, powered by a customized Mono runtime. + ### CoreCLR Originally, CoreCLR was the runtime of Silverlight and was designed to run on multiple @@ -153,7 +156,7 @@ with unique characteristics were developed for .NET runtimes over the years. **Also referred to as**: R2R -[ReadyToRun](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/readytorun-overview.md) +[ReadyToRun](.../design/coreclr/botr/readytorun-overview.md) is a file format used by the CoreCLR runtime to store AOT compiled code. `crossgen` is the AOT compiler that produces binaries in the ReadyToRun file format. @@ -171,13 +174,13 @@ by Mono runtime in environments that prohibit fallback to JIT. ### Hybrid AOT [Hybrid AOT](https://docs.microsoft.com/en-us/xamarin/mac/internals/aot#hybrid-aot) is used -by Mono runtime in environments that allow fallback to JIT. +by Mono runtime in environments that allow fallback to JIT or need IL interpreter. ### Native AOT [Native AOT](https://github.com/dotnet/designs/blob/main/accepted/2020/form-factors.md#native-aot-form-factors) is -a .NET runtime form factor with key performance characteristics (startup time, binary size and steady state throughput) competitive -with statically compiled languages. A .NET runtime flavor based on CoreCLR with these characteristics is being developed as +a .NET runtime form factor with key performance characteristics (startup time, binary size and steady state throughput and predictability) +competitive with statically compiled languages. A .NET runtime flavor based on CoreCLR with these characteristics is being developed as experimental project in [dotnet/runtimelab](https://github.com/dotnet/runtimelab/tree/feature/NativeAOT) repo. ## Frameworks