Roundup #12: TypeScript 3, EFCore.InMemoryHelpers, HTTP Caching, Standards.REST

Here are the things that caught my eye this week.  I’d love to hear what you found most interesting this week.  Let me know in the comments or on Twitter.

TypeScript 3.0

Which brings us to TypeScript 3.0! Despite the new big number, 3.0 has few breaking changes (meaning it should be veryeasy to upgrade) and introduces a new flexible and scalable way to structure your projects, powerful new support for operating on parameter lists, new types to enforce explicit checks, better JSX support, an overall better error UX, and much more!

Link: https://blogs.msdn.microsoft.com/typescript/2018/07/30/announcing-typescript-3-0/

 

EFCore.InMemoryHelpers

Provides a wrapper around the EF Core In-Memory Database Provider. Specifically works around the following EF bugs.

  • InMemory: Improve in-memory key generation
    Reasoning: For many bootstrapping and integration tests, the id generation should be predictable, i.e. an in-memory persistence should not share static mutable state. This is especially important when using unit tests as a bootstrap to generate ad-hoc data.
  • Add foreign key constraint checking to the in-memory provider
    Reasoning: It is desirable for foreign keys to be validated when running unit tests. This allows bugs to be caught earlier without the need for integration testing against a real database.
  • Add support for Timestamp/row version ([Timestamp], and .Property(p => p.X).IsRowVersion())
    Reasoning: It is desirable for exceptions to be thrown when a update violates a RowVersion. This allows bugs to be caught earlier without the need for integration testing against a real database.

Link: https://github.com/SimonCropp/EfCore.InMemoryHelpers

 

HTTP Caching – Client and Network Caching with RFC 7234

Learn how to skip making requests that you may not need to make, so you can avoid wasting time and energy processing uneccessary requests.

Highly recommend watching this.  Especially since I think ETags seem underused not just for caching purposes but for optimistic concurrency.

Link: https://www.youtube.com/watch?v=761puUy8ir4

 

Standards.REST

A collection of standards and specifications, that help make fantastic HTTP/REST APIs. Don’t reinvent the wheel, use fantastic wheels, hashed out by experts, that solve problems you hadn’t even considered yet.

As mentioned in the above talk by Phil Sturgeon, the site provides a list of RFC’s for common problems when building an HTTP API.

Link: http://standards.rest/

 

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #11: Solution-wide NuGet packages, REST vs. GraphQL, The Power of Roslyn, Blazor 0.5.0

Here are the things that caught my eye this week.  I’d love to hear what you found most interesting this week.  Let me know in the comments or on Twitter.

Solution-wide Nuget package version handling with MsBuild 15+

In order to centrally manage package versions, you can now leverage the Directory.Build.targets feature. Without going into too much detail (the linked document explains it well), Directory.Build.targets can be used to provide customizations to project files located under a certain directory (within a directory tree).

I remember seeing this from David Kean several months back on Twitter.  This is incredibly useful for keeping versions of packages consistent across projects.

Link: https://www.strathweb.com/2018/07/solution-wide-nuget-package-version-handling-with-msbuild-15/

 

REST vs. GraphQL: A Critical Review

Here is the idea: If you have never heard about the REST architectural style constraints and their implication on the properties of the resulting distributed system and you do not want to (or can’t) educate yourself, use GraphQL.

With all the buzz on Twitter about REST and GraphQL, I figured I’d toss this post in the mix.  Worth reading the comments as well to get a bigger picture.  Seems like people either sit in the REST (not CRUD but with Hypermedia) or the GraphQL camp, and nowhere in between.

Link: https://blog.goodapi.co/rest-vs-graphql-a-critical-review-5f77392658e7

 

The Power of Roslyn – Kasey Uhlenhuth

Four years ago we open sourced the C# and Visual Basic compilers and exposed their functionality through APIs as the Roslyn project. The Roslyn analyzer API empowers the developer community to be more productive by lighting up their own features in the editor in real-time–meaning anyone can write a refactoring, code fix, code style rule, or code diagnostic.

Come learn more about the Roslyn project, new APIs we’re adding, and what these live analyzers mean for you and your productivity.

I’ve always been interested in writing an Roslyn Analyzer but just wasn’t really sure where or how to get started.  If you feel the same, I recommend checking out this talk.

Link: https://www.youtube.com/watch?v=nXljhGDokqA

 

Blazor 0.5.0

Blazor 0.5.0 is now available! This release explores scenarios where Blazor is run in a separate process from the rendering process. Specifically, Blazor 0.5.0 enables the option to run Blazor on the server and then handle all UI interactions over a SignalR connection. This release also adds some very early support for debugging your Blazor .NET code in the browser!

Pretty interesting to see the updates to the JavaScript interop.  I felt like in previous versions this was the most awkward part of Blazor.

Link: https://blogs.msdn.microsoft.com/webdev/2018/07/25/blazor-0-5-0-experimental-release-now-available/

 

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #10: Octopus + Containers, Converting web.config to JSON, .NET’s Memory Management

Here are the things that caught my eye this week.  I’d love to hear what you found most interesting this week.  Let me know in the comments or on Twitter.

Kubernetes, Containers, and Octopus – An Update

A few months back we asked the Octopus community if they could spare a few minutes and brain-cycles to provide some feedback on the first-draft of our Kubernetes plans. And you certainly delivered. So first, thank-you! We sincerely appreciate everyone who shared their thoughts. The product will certainly benefit from it.

This is pretty interesting as I’ve always really loved Octopus but felt it a bit out of place for dealing with container images.   They are hitting the nail right on the head with point #3 on something similar that I’ve done.

Customers are even simulating these by including dummy packages (e.g. NuGet or Zip) in their deployment process to represent their container images, since these would be captured in the release. This is very clever, but also made us sad. It shouldn’t require that level of ingenuity.

Link: https://octopus.com/blog/kubernetes-containers-update

 

Converting web.config files to appsettings.json with a .NET Core global tool

In this post I describe how and why I created a .NET Core global tool to easily convert configuration stored in web.config files to the JSON format more commonly used for configuration in ASP.NET Core.

Really helpful post if you’re migrating from an web.config to asp.net core and want to transition to json config.

Link: https://andrewlock.net/converting-web-config-files-to-appsettings-json-with-a-net-core-global-tool/

 

Exploring NET’s Memory Management — A Trip Down Memory Lane

I was recently speaking with someone regarding the .NET GC and memory and immediately thought of this talk.   Highly recommend checking it out if you are unfamiliar with how the GC works and when memory is allocated in .NET.

The .NET Garbage Collector (GC) is really cool. It helps providing our applications with virtually unlimited memory, so we can focus on writing code instead of manually freeing up memory. But how does .NET manage that memory? What are hidden allocations? Are strings evil? It still matters to understand when and where memory is allocated.

In this talk, we go over the base concepts of .NET memory management and explore how .NET helps us and how we can help .NET – making our apps better. Expect profiling, Intermediate Language (IL), and using ClrMD to mimic some inspections dotMemory provides.

Link: https://www.youtube.com/watch?v=9FEfy9y0fFQ

 

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.