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.



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.



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.




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.



Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Practical ASP.NET Core SignalR

Practical ASP.NET Core SignalRI’ve been working on a course! Practical ASP.NET Core SignalR.  I’m going to be posting all of the sections as blog posts here on, but you can also access it free on Teachable.

This course is a complete step-by-setup guide on how to build real-time web applications using ASP.NET Core SignalR. By the end of this course, you’ll be able to build real-world, scalable, production applications using the tools and techniques provided in this course.

What you’ll learn:

  • Creating ASP.NET Core SignalR Hubs
  • Connecting to Hubs using JavaScript Clients
  • Scaling your application using Redis and Azure

What you’ll need:

  • Windows, Linux, or MacOS
  • .NET Core 2.1
  • Visual Studio Code (optional)





Get The Course!

As mentioned I will be posting on this blog with code samples for each section.  This will come in stages over the next several weeks.

If you want all the content right now, you can access the full course now by enrolling for free on Teachable.  Otherwise stay tuned to this blog and my YouTube Channel for all the content in the coming weeks.


Roundup #26: C# 8, Human Performance, Shared Framework, Migration Poll

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.


Building C# 8.0

The next major version of C# is C# 8.0. It’s been in the works for quite some time, even as we built and shipped the minor releases C# 7.1, 7.2 and 7.3, and I’m quite excited about the new capabilities it will bring.

The current plan is that C# 8.0 will ship at the same time as .NET Core 3.0. However, the features will start to come alive with the previews of Visual Studio 2019 that we are working on. As those come out and you can start trying them out in earnest, we will provide a whole lot more detail about the individual features. The aim of this post is to give you an overview of what to expect, and a heads-up on where to expect it.



Netflix JavaScript Talks – Human Performance

Is engineering an art or a science? Despite years of research and countless books on the subject, our understanding of what quality engineering means is imperfect at best. Many companies, including some here in Silicon Valley, still judge engineering performance by lines of code written and the number of bugs closed. In this talk, Jem Young (@JemYoung) covers some of the big ideas we’ve had in Netflix UI Engineering. But more importantly, what quality engineering is and what we mean when we say “human performance.”



Deep-dive into .NET Core primitives, part 2: the shared framework

Shared frameworks have been an essential part of .NET Core since 1.0. ASP.NET Core shipped as a shared framework for the first time in 2.1. You may not have noticed if things are working smoothly, but there have been some bumps and ongoing discussion about its design. In this post, I will dive deep into the shared frameworks and talk about some common developer pitfalls.



.NET Core Migration Poll

I thought this was an interesting poll with almost 1000 votes on if your team has moved to .NET Core.



Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.