Roundup #29: AWS System Manager, System.CommandLine, AzurePipelines.TestLogger, Windows Sandbox, Ambrosia

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.

.NET Core configuration provider for AWS Systems Manager

We released a new NuGet package, Amazon.Extensions.Configuration.SystemsManager. This NuGet package simplifies how your application loads the application configuration settings in the AWS Systems Manager Parameter Store into the .NET Core configuration system.

Link: https://aws.amazon.com/blogs/developer/net-core-configuration-provider-for-aws-systems-manager/

 

System.CommandLine

This repository contains the code for System.CommandLine, a library for command line parsing, invocation, and rendering of terminal output. For more information, please see our wiki.

Link: https://github.com/dotnet/command-line-api

 

AzurePipelines.TestLogger

Announce a new test logger for the Visual Studio Test Platform designed to publish your test results in real-time to Azure Pipelines. This means that you can run dotnet test from your build script on Azure Pipelines and feed your test results directly to the test summary for your build without having to rely on post-processing like the PublishTestResults Azure Pipelines task.

Link: https://daveaglick.com/posts/announcing-azurepipelines-testlogger

 

Windows Sandbox

How many times have you downloaded an executable file, but were afraid to run it? Have you ever been in a situation which required a clean installation of Windows, but didn’t want to set up a virtual machine?

At Microsoft we regularly encounter these situations, so we developed Windows Sandbox: an isolated, temporary, desktop environment where you can run untrusted software without the fear of lasting impact to your PC. Any software installed in Windows Sandbox stays only in the sandbox and cannot affect your host. Once Windows Sandbox is closed, all the software with all its files and state are permanently deleted.

Link: https://techcommunity.microsoft.com/t5/Windows-Kernel-Internals/Windows-Sandbox/ba-p/301849

 

Ambrosia: Robust Distributed Programming Made Easy and Efficient

Ambrosia is a programming language independent approach for authoring and deploying highly robust distributed applications. Ambrosia dramatically lowers development and deployment costs and time to market by automatically providing recovery and high availability.

Link: https://github.com/Microsoft/AMBROSIA

 

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #28: MinVer, API Discovery, Dependabot, Repository Pattern, Typescript

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.

 

MinVer

A minimalistic .NET package for versioning .NET SDK-style projects using Git tags.

When you want to release a version of your software, whether it’s a pre-release, RTM, patch, or anything else, simply create a tag with a name which is a valid SemVer 2.0 version and build your projects. MinVer will apply the version to the assemblies and packages. (If you like to prefix your tag names, see the FAQ.)

Link: https://github.com/adamralph/minver

 

REST Fest 2018: Kin Lane

Kin Lane (API Evangelist) – ”API Discovery in the Real World is Complicated” – 28 September 2018

REST Fest 2018 \ Kin Lane (API Evangelist) \ 2018 Keynote from REST Fest on Vimeo.

Link: https://vimeo.com/295217613

Dependabot

Dependabot pulls down your dependency files and looks for any outdated or insecure requirements.

If any of your dependencies are out-of-date, Dependabot opens individual pull requests to update each one.

You check that your tests pass, scan the included changelog and release notes, then hit merge with confidence.

Link: https://dependabot.com/

 

Stop Using Repository Pattern With an ORM

In this post I’m going to list some reasons  suggested for using repository pattern. Then we’re going to see if these reasons really needs these kind of patterns to be solved. Then I’m going to propose other alternatives for solving  these problems.

Link: http://hamidmosalla.com/2018/11/25/stop-using-repository-pattern-with-an-orm/

 

dotJS 2018 – Anders Hejlsberg

How do you define and implement a static type system for a dynamic language like JavaScript, and why would you even care to? Anders explores how TypeScript came to be, how it differs from classic type systems, and how it can be beneficial even if you don’t like types.

If you’re not on the TypeScript train yet, why not? But really, it might be worth a watch if you aren’t.

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

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #27: JavaScript Trash Fire, Maintainers are Jerks, Functions & CosmosDB, Dev Setup Scripts

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.

Today’s JavaScript trash fire and pile on

Four years ago I wrote a slightly inflamatory blog on what still sucks in front-end dev. One of the points was on Bower and how JS library management sucks. Sadly, the tools have changed, but JS library managment still sucks.

This post is in response to the recent npm even-stream package that had malicious code injected into it by a new maintainer.

Link: https://medium.com/@cnorthwood/todays-javascript-trash-fire-and-pile-on-f3efcf8ac8c7

 

Open-Source Maintainers are Jerks!

As software developers we often make use of open-source software (OSS) but do we ever think about all the man hours that go into developing and supporting the project. When OSS breaks, or we need a new features, we log an issue on gitHub and then sit back awaiting a response. After a week of waiting we start complaining about how badly the project is run. The thing about OSS that’s too often forgetten, it’s AS-IS, no exceptions. Different projects may operate differently, with more or less people, with work being prioritised differently, on differing release schedules but in all cases the software delivered is as-is, meaning that there is absolutely no SLA. In this talk we’ll look at a day in the life of an OSS maintainer: what drives them, what annoys them and what keeps them up at night. Maintainers aren’t jerks, they just care about the project more than you do.

Thought this was a worthwile related talk to watch in regards to the npm package issue this week.

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

 

Serverless Data APIs with Azure Functions and Cosmos DB

Azure Functions, Microsoft’s serverless offering, allow developers to focus on their code and not be concerned with infrastructure or DevOps. And thanks to a slew of built-in integrations, it’s also easy to have your functions get and send data to various services or even be triggered by events in those services. One such integration is with Azure Cosmos DB, the multi-model, globally distributed NoSQL data service. Cosmos DB exposes data as documents that you can access via SQL, JavaScript MongoDB or Cassandra as well as graph and key-value store. In this session, you’ll see how easily you can build an API from a set of Azure Functions that interact with Cosmos DB documents and some other services. We’ll go all cross-platform with Visual Studio Code and Node JS.

Julie Lerman – Serverless Data APIs with Azure Functions and Cosmos DB | Øredev 2018 from Øredev Conference on Vimeo.

Link: https://vimeo.com/302679933

 

windows-dev-box-setup-scripts

The goal of this project is to provide a central place to share ideas for streamlining dev box setup and provide sample scripts for common dev scenarios. It’s likely you will want to take the scripts here and modify them to fit your particular needs.

I was recentlys setting up a new dev machine and Rich Turner pointed me to this repo.

 

Guarded Devirtualization

Guarded devirtualization is a proposed new optimization for the jit in .Net Core 3.0. This document describes the motivation, initial design sketch, and highlights various issues needing further investigatio

The .Net Core jit is able to do a limited amount of devirtualization for virtual and interface calls. This ability was added in .Net Core 2.0. To devirtualize the jit must be able to demonstrate one of two things: either that it knows the type of some reference exactly (say because it has seen a newobj) or that the declared type of the reference is a final class (aka sealed). For virtual calls the jit can also devirtualize if it can prove the method is marked as final.

Link: https://github.com/dotnet/coreclr/blob/5af32b00186ba37f5b2cdc4b0a9b5715d7807f1d/Documentation/design-docs/GuardedDevirtualization.md

 

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.