Our Blog

Prepare for .NET Core 3 and .NET 5

By Juan Pablo Ventoso
August 3, 2019

Photo by Caspar Camille Rubin on Unsplash, edited by Juan Pablo Ventoso

Introduction

It’s been a while now since .NET Core is out there: It was released back in June 2016 and it kept growing since then. The main advantages when comparing with .NET Framework is that .NET Core is free, open-source and cross-platform. It also has several performance improvements that gains up to 600% increase for some particular functions like converting elements to a string, or more than 200% for some LINQ queries, and a general performance boost in application startup.

But it also has drawbacks: Some third party libraries are still not fully supported, so while they can still be used, the compiled results will only be portable to Windows. Also, .NET Core 2.2 (the latest release to date) doesn’t yet have support for Windows Presentation Foundation (WPF) or Windows Forms applications… But it looks like this is going to change soon.

Next stop: .NET Core 3

In the 2019 Build Conference that took place in May, .NET Core 3 was announced: It’s expected to be released in November this year, and it will finally include support for Windows desktop development (WPF, UWP and Windows Forms). It will also …

Ruby Gem Spotlight: DRG

By Patrick Lewis
July 31, 2019

Photo by Ioan Sameli, used under CC BY-SA 2.0, cropped from original.

The DRG gem is “a Ruby utility to help automate dependency management using Bundler.” I use DRG to manage gem versions in all of my Rails projects and have found it to have several useful features for managing project dependencies in Gemfiles.

Pinning with ‘drg:pin’

DRG works by adding a variety of Rake tasks for updating your Gemfile. I like to start with rake drg:pin:minor to pin a project’s Gemfile to the approximate minor version of the gems currently installed in a project’s Gemfile.lock. This fills in missing version information where needed, and updates the Gemfile to better reflect the state of the currently-installed gems.

Here’s an example of a Gemfile from a freshly generated Rails project before and after running rake drg:pin:minor:

Before:

gem 'bootsnap', '>= 1.1.0', require: false
gem 'drg'
gem 'puma', '~> 3.11'
gem 'rails', '~> 5.2.3'
gem 'sass-rails', '~> 5.0'
gem 'sqlite3'
gem 'uglifier', '>= 1.3.0'

group :development, :test do
  gem 'byebug', platforms: [:mri, …

A tribute to Kyle Simpson’s JavaScript book series

By Árpád Lajos
July 24, 2019

Photo by othree, used under CC BY 2.0

Inspired by the Ruby Fight Club, a group of us have been reading Kyle Simpson’s You Don’t Know JS series (1st edition; in 2020 Kyle started publishing drafts of the 2nd edition of the books). These books are a great source of inspiration and available for free. I meet weekly with our small group to discuss chapters from these books. Each time we have a presenter who walks us through the chapter that we all read beforehand.

During these sessions we have learned a lot about JavaScript, but also about preparing presentations. The increasing quality level of the meetings was noticable each week. I think we all owe a large thanks to Kyle Simpson. In this article I will focus on the book “You Don’t Know JS: ES6 and Beyond”.

Past, present and future

ECMAScript (ES for short) was versioned with a small number up until now, like 5. ES1 and ES2 were not widely known or implemented. ES3 was used by Internet Exporer 6–8 and Android 2.x. ES4 never came out. ES5 came out in 2009. ES5.1 came out in 2011 and was widely used by Firefox, Chrome, Opera, Safari, etc.

Now, version names will be in the format ES, but it might change to a per-feature basis.

In the …

GraphQL Client Libraries

By Zed Jensen
July 19, 2019

Photo by Pietro De Grandi on Unsplash

Last week I covered some of the more popular GraphQL libraries for servers. This post will cover some options for GraphQL clients. Similarly to last week, the examples in this post won’t necessarily be everything you’d need to get a server running; instead, they’re designed to give you an idea of what it might be like to use each library. If you’re unfamiliar with GraphQL, please check out my earlier post GraphQL — An Alternative to REST for more information.

Apollo Client

This is the client with which I’m the most familiar—I’ve used its React version, so I’ll show an example of how you’d use it with a React component. However, there are also versions available for Angular, Vue.js, native iOS and Android, and Scala.js.

First we need to set up our Apollo client so it knows where our server is:

import ApolloClient from "apollo-boost";

const client = new ApolloClient({
  uri: "https://your-server.com"
});

Next, you need to make sure the root component of your application is wrapped in an ApolloProvider:

class App extends Component {
  render() {
    return (
      <ApolloProvider client={client}>
        <RestOfYourApp …

Mocking asynchronous database calls in .NET Core

By Juan Pablo Ventoso
July 16, 2019

Photo by Björn Söderqvist, used under CC BY 2.0

Introduction

Whenever we like—or are forced!—to develop using a TDD (test-driven development) approach or a more traditional practice, unit testing should be always a part of our development process. And when it comes to .NET Core, no matter what framework we choose (xUnit, MSTest or other), we will probably need to use a mock library.

What is mocking? By definition, it’s making an imitation. Objects usually depend on other objects, which could rely on database connections, local files or external APIs. So when we need to test the behavior of a particular object, we will have to isolate its dependencies, replacing those objects with fake versions. And that’s where mocking—and the Moq library—comes into place: it’s a set of classes that allows us to easily create and handle those fake objects.

So, assuming we already have a .NET Core solution with a test project included, all we need to do to add Moq is install the package from the NuGet console in Visual Studio:

Install-Package Moq

Mocking data with async calls support

One of the first showstoppers I’ve encountered when trying to add unit tests to an existing project was to mock …

GraphQL Server Libraries

By Zed Jensen
July 12, 2019

Photo by Jon Flobrant on Unsplash

This post is a followup to my previous post, GraphQL — An Alternative to REST. Please check that out for an introduction to GraphQL and what makes it different from other API solutions. I’ve collected a list of some of the currently-maintained GraphQL libraries for a few different languages, along with some examples (most of which aren’t fully functional on their own, they’d need more configuration) so you can see what it might be like to use GraphQL in your project. I’ll be focusing on the ways each of these libraries implement GraphQL and what you’d need to do to start a project with each of them, so if you have questions about GraphQL itself, please check out my other blog post.

Apollo Server (JavaScript/TypeScript)

Apollo GraphQL has libraries for both a GraphQL server and client (which I’ll discuss later). Apollo Server can be used both as a standalone server as well as with libraries like Express. Apollo Server is the server library I have the most experience with—I wrote a server last year using Express and Apollo Server, along with a client that used Apollo Client. I’m a fan of the flexibiliy of Apollo, but it takes more work to set up than …

An Introduction to Neural Networks

By Ben Ironside Goldstein
July 1, 2019

Photo by Sudhamshu Hebbar, used under CC BY 2.0

Earlier this year I wrote a post about my work with a machine-learning camera, the AWS DeepLens, which has onboard processing power to enable AI capabilities without sending data to the cloud. Neural networks are a type of ML model which achieves very impressive results on certain problems (including computer vision), so in this post I give a more thorough introduction to neural networks, and share some useful resources for those who want to dig deeper.

Neurons and Nodes

Neural networks are models inspired by the function of biological neural networks. They consist of nodes (arranged in layers), and the connections between those nodes. Each connection between two nodes enables one-way information transfer: a node either receives input from, or sends output to each node to which it is connected. Nodes typically have an “activation function”, parameterized by the node’s inputs, and its output is the result of this function.

As with the function of biological neural networks, the emergence of information processing from these mathematical operations is opaque. Nevertheless, complex artificial neural networks are capable of feats such as …

Deploying production Machine Learning pipelines to Kubernetes with Argo

By Kamil Ciemniewski
June 28, 2019

Image by Wikimedia Commons

In some sense, most machine learning projects look exactly the same. There are 4 stages to be concerned with no matter what the project is:

1. Sourcing the data
2. Transforming it
3. Building the model
4. Deploying it

It’s been said that #1 and #2 take most of ML engineers’ time. This is to emphasize how little time it sometimes feels the most fun part—#3—gets.

In the real world, though, #4 over time can take almost as much as the previous three.

Deployed models sometimes need to be rebuilt. They consume data that need to constantly go through points #1 and #2. It certainly isn’t always what’s shown in the classroom, where datasets perfectly fit in the memory and model training takes at most a couple hours on an old laptop.

Working with gigantic datasets isn’t the only problem. Data pipelines can take long hours to complete. What if some part of your infrastructure has an unexpected downtime? Do you just start it all over again from the very beginning?

Many solutions of course exist. With this article, I’d like to go over this problem space and present an approach that feels really nice and clean.

Project description

End Point Corporation was founded in 1995. …