BT

Facilitating the spread of knowledge and innovation in professional software development

Contribute

Topics

Choose your language

InfoQ Homepage Language Design Content on InfoQ

  • C# 8 Nullable Reference Types Update

    Work continues on nullable refence types for C# 8, revealing edge cases that need to be addressed before the final release and new opportunities for reducing the amount of boilerplate developers have to write.

  • C# 8 Pattern Matching Enhancements

    C# 7 laid the groundwork for pattern matching, but a lot of features had to be left on the cutting room floor. With the extra time C# 8 needs, many of these are being picked up.

  • C# 8 Nullable Value Type Enhancements

    First introduced in .NET 2, very little has changed for Nullable<T> over the last decade and a half, but that looks like it is about to change. Much of the work going into supporting nullable reference types in C# 8 may be applied to nullable value types.

  • C# Default Interface Methods Update

    As support for Default Interface Methods gets closer to completion, potential issues are raised. While much has been accomplished, this is a complex feature and many of the specifics haven’t been settled yet.

  • C# 8 More Small Features

    Though C# 8 is supposed to be released this year and the roadmap for C# 8.x and 9 are beginning to be formed, Microsoft is continuing to approve features for the next release.

  • Microsoft Introduces Bosque, a Programming Language for Writing Easy-to-Reason-about Code

    Microsoft has recently introduced the Bosque programming language, an investigative language design research project for writing code that is simple, obvious, and easy-to-reason-about for both humans and machines. The language derives from a combination of TypeScript inspired syntax and types, plus ML and Node/JavaScript inspired semantics.

  • Nullable Reference Types in F# 5

    The introduction of nullable reference types in C# represents the biggest change to how .NET developers write code since async/await. Once it goes live, countless libraries will have to be updated with nullable annotations in order for this feature to work correctly. And to ensure interoperability, F# will need to respond in kind.

  • C# Futures: Deferred Error Handling

    When writing robust software, there is often a need to perform a series of retriable operations. In order to make the system robust, each operation in the series can be coded so it is independent of the status of the previous operation. Before the deferred error handling proposal, this could be tedious to code.

  • C# Futures: Pointer Math

    Interoperability with native platforms often require very specific coding patterns that involve the manipulation of pointers. While this can be done via a shim written in C, the proposal titled Operators should be exposed for System.IntPtr and System.UIntPtr seeks to offer that ability directly in C#.

  • C# Futures: Static Delegates and Function Pointers

    With each release of C#, it gains more low-level capabilities. While not useful to most business application developers, these features allow for high performance code suitable for graphics processing, machine learning, and mathematical packages. In these next two proposals, we see new ways to reference and invoke functions.

  • C# Futures: Lambda Attributes

    Attributes are a key part of .NET’s metadata processing capabilities. They are used by compilers, static analyzers, and runtime libraries for a variety of purposes. While normal functions/methods can have attributes, prior to this proposal lambdas and anonymous functions could not.

  • C# Futures: Defer

    Best known for its use in Go and Swift, C# proposal #1398 seeks to add defer statements. If you are not familiar with the concept, it can be summarized as a finally block appearing at the beginning of some code instead of the end.

  • C# 8: Generic Attributes

    Attributes have been part of .NET since the beginning. As such, they were created before generics were introduced and never quite caught up. Though supported by the CLR, before this proposal C# didn’t offer the ability to use generic attributes.

  • C# 8: Caller Expression Attribute for Assertions and Automated Testing

    Currently C# supports caller info attributes for file name/path, line number, and the name of the calling method or property. With the Caller Expression Attribute proposal, expressions are added to the list.

  • C# 8: Type Inference for the New Keyword

    In many situations, there is only one possible type allowed in a given place. And yet C# still requires you to explicitly list the type. If the Target-typed `new` expression proposal is adopted, such boilerplate code will no longer be necessary.

BT