Author: Almir Vuk

Last week, during the Microsoft Build 2024, Microsoft announced the new preview features of C# 13, the latest version of the popular .NET programming language. As the most notable improvements to params parameters, the new extension types are announced, and the release includes several performance and memory enhancements for .NET developers.

In C# 13, the params keyword is no longer limited to arrays. When used before a parameter, params allow a method to accept a comma-separated list of zero or more values, which are placed in a collection of the specified type.

Now, the params parameter type can be any collection type compatible with collection expressions, such as List, Span, and IEnumerable. It is stated that custom collection types can also be used if they follow specific guidelines.

void PrintList(params IEnumerable list) 
    => Console.WriteLine(string.Join(", ", list));

PrintList("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");

// prints "Sun, Mon, Tue, Wed, Thu, Fri, Sat"

Furthermore, performance enhancements were a key focus in C# 13, particularly with the use of System.Span and System.ReadOnlySpan, which as stated helps reduce memory allocations.

Now, the values passed to the params parameter are implicitly converted to the span type, which as reported ensures the most efficient method is selected, especially when overloaded methods differ by span or array usage.

The official blog post states the following:

Many of the methods of the .NET Runtime are being updated to accept params Span, so your applications will run faster, even if you don’t directly use spans. This is part of our ongoing effort to make C# faster and more reliable. It’s also an example of the attention we give to ensuring various C# features work well together.

C# 13 also enhances params support for interfaces. When an interface is specified as a parameter type, it indicates a requirement for any implementing type. The compiler can choose the best available type that fulfils the interface, potentially using an existing type or creating one as needed.

As explained, this design ensures that dependencies on the underlying concrete collection type are minimized, allowing for flexibility and optimization. The compiler’s ability to select the optimal concrete type when a list of values or a collection expression is passed further enhances the efficiency and adaptability of the code.

The announcement of the future addition is related to Extension types which in C# 13 will be expanded by providing additional methods, properties, and members to underlying types. These extension types can be implicit, applying to all instances of the underlying type, or explicit, applying only to instances explicitly converted to the extension type.

The original announcement blog post received a few interesting ideas about improvements and suggestions for C# language, and based on different threads and forums overall community feedback is positive, with a note and written excitement about Extension types, which seems to be a liked feature by the community.

The official Microsoft Build website also publicised the session recording with the title What’s New in C# 13 and it is highly recommended that developers watch it. Other C# additions are related to the new lock object, new escape sequence, method group natural type and Implicit index access

Lastly, readers can find more about the available C# 13 features on the official language documentation page.

Last week, during the Microsoft Build 2024, Microsoft announced the new preview features of C# 13, the latest version of the popular .NET programming language. As the most notable improvements to params parameters, the new extension types are announced, and the release includes several performance and memory enhancements for .NET developers.

In C# 13, the params keyword is no longer limited to arrays. When used before a parameter, params allow a method to accept a comma-separated list of zero or more values, which are placed in a collection of the specified type.

Now, the params parameter type can be any collection type compatible with collection expressions, such as List, Span, and IEnumerable. It is stated that custom collection types can also be used if they follow specific guidelines.

void PrintList(params IEnumerable list) 
    => Console.WriteLine(string.Join(", ", list));

PrintList("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");

// prints "Sun, Mon, Tue, Wed, Thu, Fri, Sat"

Furthermore, performance enhancements were a key focus in C# 13, particularly with the use of System.Span and System.ReadOnlySpan, which as stated helps reduce memory allocations.

Now, the values passed to the params parameter are implicitly converted to the span type, which as reported ensures the most efficient method is selected, especially when overloaded methods differ by span or array usage.

The official blog post states the following:

Many of the methods of the .NET Runtime are being updated to accept params Span, so your applications will run faster, even if you don’t directly use spans. This is part of our ongoing effort to make C# faster and more reliable. It’s also an example of the attention we give to ensuring various C# features work well together.

C# 13 also enhances params support for interfaces. When an interface is specified as a parameter type, it indicates a requirement for any implementing type. The compiler can choose the best available type that fulfils the interface, potentially using an existing type or creating one as needed.

As explained, this design ensures that dependencies on the underlying concrete collection type are minimized, allowing for flexibility and optimization. The compiler’s ability to select the optimal concrete type when a list of values or a collection expression is passed further enhances the efficiency and adaptability of the code.

The announcement of the future addition is related to Extension types which in C# 13 will be expanded by providing additional methods, properties, and members to underlying types. These extension types can be implicit, applying to all instances of the underlying type, or explicit, applying only to instances explicitly converted to the extension type.

The original announcement blog post received a few interesting ideas about improvements and suggestions for C# language, and based on different threads and forums overall community feedback is positive, with a note and written excitement about Extension types, which seems to be a liked feature by the community.

The official Microsoft Build website also publicised the session recording with the title What’s New in C# 13 and it is highly recommended that developers watch it. Other C# additions are related to the new lock object, new escape sequence, method group natural type and Implicit index access

Lastly, readers can find more about the available C# 13 features on the official language documentation page.

Azure API Management introduced TLS 1.3 support in the V1 and V2 tiers during the initial week of February 2024. As reported, the rollout will occur progressively across regions. Inbound traffic for both V1 and V2 tiers will inherently support TLS 1.3 for incoming requests from API clients.

As reported, for outbound traffic in V1 tiers, manual activation of TLS 1.3 will be required, while V2 tiers will receive support for outbound traffic with TLS 1.3 in a subsequent update. Additionally, an update will be released in the coming weeks for the enabling or disabling of ciphers of outbound traffic through various channels such as the Azure Portal, ARM API, CLIs, and SDKs.

TLS 1.3 represents the latest iteration of the widely used security protocol on the internet. It secures communication channels between endpoints by encrypting data, thus superseding outdated cryptographic algorithms, bolstering security compared to older versions, and prioritizing encryption throughout the handshake process.

Unlike previous versions, TLS 1.3 ensures confidentiality in client authentication without the need for additional round trips or CPU costs. At the same time, it enhances security measures significantly.

According to Microsoft, integrating API clients or services with TLS 1.3 protocol should not pose any issues for those employing client libraries like browsers or .NET HTTP clients. However, the manual configuration of TLS handshakes for clients connected to Azure API Management warrants review to ensure compatibility with TLS 1.3.

Developers are strongly encouraged to test TLS 1.3 in their applications and services. The simplified list of supported cipher suites reduces complexity and guarantees specific security features such as forward secrecy (FS).

Regarding the impact of TLS 1.3 Impact on API Clients, Fernando Mejia from Microsoft stated the following:

We do not expect TLS 1.3 support to negatively impact customers. TLS 1.2 clients will continue to work as expected. However, client certificate renegotiation is not allowed with TLS 1.3, if your Azure API Management instance relies on client certificate renegotiation for receiving and validating client certificates, your instance of API Management will not be updated to enable TLS 1.3 by default and will default to TLS 1.2 to avoid any impact on your API clients.

The protocol enables encryption earlier in the handshake, providing better confidentiality and preventing interference from poorly designed middle boxes. TLS 1.3 encrypts the client certificate, so client identity remains private, and renegotiation is not required for secure client authentication.

In addition to the announcement, the original blog post includes an informative FAQ section addressing common questions from the community regarding the addition of TLS 1.3 support. One such question is, What to expect with the initial TLS 1.3 (preview) support?

Beginning February 5th, some customers may begin to see incoming client requests using TLS 1.3 handshakes if the clients also support TLS 1.3. Customers using Azure API Management will not have control over when the update arrives, it will be part of a general release. You can expect these TLS 1.3 handshakes to stabilize by the end of March 2024.

Lastly, Microsoft encourages users to provide feedback on the TLS 1.3 preview in Azure API Management. For questions, users can seek answers from community experts on Microsoft Q&A. Also, users with support plans requiring technical assistance can create a support request using Azure Portal.

The Grafana 10.3 release introduces a range of enhancements for visualization, instance management, alerting, and log analysis. These upgrades include improved tooltips and zoom functionality for data navigation, alongside features for tracking metric changes and visualizing system health. Additionally, enhancements in alerting organization and log analysis are also available.

The first notable improvement is the addition of enhanced tooltips for data visualization. These tooltips feature colour indicators for easy data differentiation, uniform time display across panels, and support for longer labels, providing users with more detailed information and a consistent experience across all Grafana panels.

Another enhancement is the introduction of pan and zoom functionality within the Canvas panel. This feature allows users to navigate through data as reported more effectively, which is particularly beneficial for those working with large-scale or highly detailed canvas visualizations.

Users can now track metric changes over time in stat panels, which, according to the Grafana team, enables an easier understanding of metric growth. Integration of colour indicators for percentage change offers a quick way to identify trends in data. Note that this feature is generally available in all editions of Grafana.

Furthermore, enum values can be plotted in time series and state timeline visualizations, enabling users to visualize system and service health effectively. This feature utilizes the convert field transformation to display enum values, enhancing visualization capabilities.

The release also introduces improved management capabilities for Grafana instances, including enhanced control over anonymous access. Users can now monitor anonymous devices connected to their instance and limit the number of anonymous devices for better security and resource management, with a note that this feature is generally available in Grafana open source and Grafana Enterprise

Furthermore, the release offers the ability to query across multi-stack data sources, simplifying the querying process for users managing metrics or logs across multiple tenants in Grafana Cloud.

Another significant improvement is the enhanced reporting experience, allowing users to share complete table data in PDF reports. Two new options are introduced: embedding all table data as a PDF appendix and generating a separate PDF for table data.

In terms of alerting, the release includes improvements in alerting contact points organization and visibility, simplifying the alert management experience. The UI now displays notification policies linked to each contact point for improved understanding of alert configurations.

Regarding the Log analysis, the introduction of a new popover menu in Grafana brings improvements for search. According to the original announcement, this feature simplifies searches and adjusts queries by automatically offering options to copy text and add filters. As stated, it is compatible with various log data sources, such as Grafana Loki and Elasticsearch, while providing improved efficiency in single and mixed data source modes.

In addition to the release of Grafana 10.3, users could find it helpful to explore the official YouTube channel, which published a playlist of 16 videos showcasing all the new features available in this version. These videos provide detailed demonstrations and explanations of each feature, offering users a comprehensive overview of the enhancements introduced in Grafana 10.3.

Lastly, to address a technical issue within the Grafana release package management process, Grafana 10.3.0 and Grafana 10.3.1 are being simultaneously released. Grafana 10.3.1 contains no breaking or functional changes compared to 10.3.0. Users can explore the documentation for Grafana 10.3.0.

Microsoft has introduced the MSTest Runner, a lightweight test runner designed specifically for MSTest tests. The primary goal of MSTest Runner is to enhance test portability, reliability, and speed while providing an extensible testing experience for users.

The new MSTest Runner was introduced as an independent portable executable, with a focus on eliminating the need for external tools like vstest.console, dotnet test, or Visual Studio during test execution. The development team describes this in a way that this approach makes it well-suited for authoring tests on devices with limited power or storage, offering a simplified testing solution.

As stated, developers of all skill levels and project sizes can benefit from the MSTest Runner, which comes bundled with the MSTest.TestAdapter NuGet package, version 3.2.0 onwards. It is integrated with common testing environments, including dotnet test, vstest.console, Visual Studio Test Explorer, and Visual Studio Code Test Explorer.

Concerning the comparisons to VSTest, as reported the MSTest Runner offers several advantages like portability, performance, reliability and extensibility.

In terms of portability, it simplifies test execution by running tests directly from an executable, eliminating complexities associated with traditional test infrastructure. With MSTest Runner projects are treated as regular entities, enabling developers to leverage existing dotnet tooling and run tests on multiple computers without additional setup.

It is announced that there is a plan for NativeAOT support. Also, on GitHub developers can explore the sample for running tests against a dotnet application hosted in a docker container that has no dotnet SDK available.

Furthermore, Performance-wise, the MSTest Runner will optimise resource usage on build servers, utilizing one less process and reducing inter-process serialized communication. As stated by the development team behind it, the internal Microsoft projects adopting this runner observed substantial savings in CPU and memory usage, with some projects completing tests three times faster while using four times less memory compared to the dotnet test.

Continuing with performance, there is an interesting question by user Michael Dietrich related to performance and its improvements raised attention. The question received a very detailed answer from Jakub Jareš, and it is highly recommended for readers to read through it.

On the other hand, the MSTest Runner introduces new defaults prioritizing safety and reducing the likelihood of accidentally missing test execution. Also, because of its architecture, without folder scanning, dynamic loading, or reflection for extension detection, guarantees consistent behaviour in both local and CI environments. Following, the runner’s asynchronous and parallelizable design minimizes hangs or deadlocks, addressing common issues observed when using VSTest.

Furthermore, regarding the extensibility the MSTest Runner offers a flexible model, allowing users to extend or override various aspects of test execution. This model supports custom report generators, test orchestration, loggers, and additional command-line options. Microsoft provides a list of optional extensions, with a statement of ongoing efforts to enhance the library with more features.

The original blog post announcement carries a very active comments section, between community members and the development team. The community feedback was overall very positive and active with questions and reactions.

A user called, Michael Taylor asked about the future of Test Explorer in Visual Studio and pipelines utilizing VS Test and the dotnet CLI for running tests. Jakub Jareš responded comprehensively, offering detailed insights and outlining plans for these tools.

Stating that the recommendation is to use the MSTest runner for new MSTest projects. There are plans to update MSTest templates to automatically utilize the MSTest runner as the default option. Additionally, a parameter, --disable-runner, will be provided for those who wish to opt out of using the MSTest runner.

Additionally, user Michael Dietrich raised another question about the compatibility of the runner with other test frameworks. The response indicated that, while the runner currently supports only MSTest, it was intentionally built on framework-agnostic building blocks.

By explaining that the decision was made to focus on MSTest, which provides greater flexibility, ease of backward compatibility, and quicker, more confident implementation of changes due to the team’s familiarity with the MSTest codebase. Developers are also encouraged to vote and give their feedback regarding the other test frameworks.

Lastly, for readers who are interested in more project details and updates can explore the official GitHub repository.

OpenTofu 1.6.0 is now generally available. A community-driven open-source fork of Terraform under the Linux Foundation, now offers a stable release with many features, including advanced testing features for configurations and modules, enhanced S3 state backend with new authentication methods, a new provider and module registry, and many more improvements and bug fixes.

The 1.6.0 release of OpenTofu introduces a range of new features aimed at enhancing stability and functionality. Notable among these is the testing feature, enabling users to assess OpenTofu configurations and allowing module authors to conduct module tests, therefore strengthening overall stability. Integration with the core of OpenTofu is complete, ensuring a seamless user experience.

Additionally, the S3 state backend has experienced a substantial update, featuring numerous new authentication methods while maintaining compatibility with S3-compatible object storage. The release also unveils a new provider and module registry adopting a Homebrew-like architecture, exclusively based on a git repository.

Hosted on CloudFlare R2, this registry is characterized by its responsiveness and high availability, with the process of publishing a new provider or module streamlined to a mere pull request.

Beyond these highlights, the release incorporates a multitude of minor improvements, bug fixes, and performance enhancements, detailed comprehensively in the changelog.

The release and work on OpenTofu are powered by the active community effort. Sebastian Stadl, Core OpenTofu Contributor stated the following:

This OpenTofu GA release is the culmination of 4 months of worldwide community efforts across 5 continents, from hundreds of contributors and over five dozen developers

Looking forward, the OpenTofu project acknowledges the importance of compatibility with Terraform, as reported the project commits to maintaining a reasonable level of compatibility, avoiding disruptive changes to DSL or provider protocols.

The original blog announcement of the GA version states that the 1.7 release has a roadmap which includes the introduction of client-side state encryption, as reported as a long-awaited feature by users for securing state and plan files end-to-end. Also, it is stated that this is valuable to projects working in a regulated environment, and ones going for maximum security.

Initially, support will be extended for user-provided keys and select key management services. Future developments may include a plugin system for introducing additional key management services, depending on community feedback and usage patterns.

Furthermore, in responding to general community requests, OpenTofu is exploring the implementation of parameterizable backends, providers, and modules. As stated this involves the possibility of parameterizing module versions using variables and instantiating providers through for_each parameters on a static list of values. The project aims to address these needs in due course.

In addressing the demand for new state backends, the project aims for the introduction of a plugin system similar to providers. This approach, focusing on third-party extensibility, aligns with the project’s commitment to enhancing the overall ecosystem and offering users a variety of choices.

While these substantial improvements are on the horizon, OpenTofu remains attentive to the diverse needs of its user base. The project actively encourages community participation, welcoming suggestions, and contributions. Users are encouraged to submit issues for any features or enhancements in OpenTofu, ensuring a collaborative and user-centric evolution of the platform.

Lastly, the guide for migrating to OpenTofu from Terraform is available for interested readers for exploration and guidance.

Back in November, during the .NET Conf Microsoft released F# 8.0 as part of the .NET 8 release. The new version of F# brings in many features to make F# code simpler, more uniform, and apps more performant. The new features are related to language changes, improved diagnostics, quality-of-life improvements, and performance boosts for project compilation and upgrades.

In the latest F# release, several noteworthy features have been introduced to enhance the language’s expressiveness and efficiency. One significant addition is the shorthand for defining simple lambda functions, which proves particularly useful for situations where a lambda function is confined to an atomic expression on the lambda argument. This shorthand, expressed as (fun x -> x.Property), simplifies the code, making it more concise and readable.

A second key feature addresses the copy-and-update functionality for nested records. This enhancement simplifies the process of copying and updating nested record fields, providing developers with a more efficient and straightforward approach to field manipulation within records.

The while! (while bang) feature, initially announced in an earlier preview, has been officially integrated. This feature simplifies the use of computation expressions, especially when looping over a boolean condition that needs evaluation within the computation expression, such as within an async{} block.

let doStuffWithWhileBang =
    async {
        while! asyncCondition do
            count <- count + 2
        return count
    }

F# 8 also introduces an extended string interpolation syntax, drawing inspiration from C#. This improvement enhances the support for existing interpolated strings in F#. Literal text output can now seamlessly combine with values and expressions by enclosing them in braces {}. However, to use braces as literal parts of the output, they need to be escaped by doubling (via {{ and }}). As stated, this can be helpful when dealing with texts containing numerous braces, such as when embedding other languages in F# strings, like JSON, CSS, or HTML-based templating languages like mustache.

Furthermore, another significant update involves string literals used in built-in printing functions (printfn, sprintfn, etc.). In previous versions, the specified format had to be a string literal typed directly at the usage location. With F# 8, string literals defined elsewhere are now supported. Additionally, developers can define a string literal using a concatenation of existing string literals. This allows for the reuse of commonly repeated format specifiers as patterns, reducing redundancy in the codebase.

[] 
let formatBody = "(%f,%f)"
[] 
let formatPrefix = "Person at coordinates"
[] 
let fullFormat = formatPrefix + formatBody

let renderedCoordinates = sprintf formatBody 0.25 0.75
let renderedText = sprintf fullFormat 0.25 0.75

There are some other changes also, including arithmetic operators in literals, type constraint intersection syntax, extended fixed bindings, simplified [] method definitions and others. The release also includes the changes related to new and improved diagnostics.

With this release, F# is experiencing significant enhancements to improve uniformity and consistency. Static members can now be declared and implemented in interfaces, emphasizing concrete members in contrast to F#7’s static abstract members. Additionally, static bindings, including static let and static do, are extended to discriminated unions, records, structs, and types without primary constructors, promoting the encapsulation of data and logic within type definitions.

[]
type IDemoable =
    abstract member Show: string -> unit
    static member AutoFormat(a) = sprintf "%A" a

Also, the try-with code construct is now supported within collection builders, such as seq{} for IEnumerable definitions, [] for list builders, and [||] for array builders. This extension enables exception handling within these expressions, allowing for various combinations of ‘try’ and ‘with’ scenarios, enhancing the overall clarity and conciseness of F# code.

F# 8 introduces several quality-of-life improvements. One significant improvement is the introduction of trimmability for compiler-generated code, enhancing code clarity and reducing unnecessary elements.

Parser recovery has been refined, contributing to a more robust and resilient parsing process for improved code comprehension. Strict indentation rules have been implemented, promoting consistent code formatting and enhancing readability across F# projects.

Autocomplete functionality has been refined, providing an improved developer experience by offering more accurate and context-aware suggestions during coding. Additionally, [] unions now support over 49 cases, expanding the versatility of this construct within F#.

Compiler performance has been a focal point in this release, addressing crucial aspects related to the F# compiler and associated tooling. Special attention has been given to two key areas F# – incremental builds of large graphs of projects via the Reference assemblies feature, and CPU-parallelization of the compiler process.

Overall community feedback about this release, was positive and a couple of community members wrote that they already experienced the performance improvements. A user called David N wrote the following comment on the original blog post announcement:

Brilliant work. It’s taken me a while to get to read this and I see I have several things to go and try out now. Especially the new experimental compiler optimisations. I had already been trying the graph optimisations and they gave a 20% improvement to my project build times just with that one feature.