Scott Guthrie recently shared one of my favorite anecdotes on his Azure Red Shirt Tour. A Microsoft customer regularly invokes 1 billion (yes, that’s with a “B”) Azure Functions per day. The customer reached out to support after the first month thinking there was a bug in the billing system, only to find out that the $72 was in fact correct. How is that possible? Azure Functions is a serverless compute platform that allows you to focus on code that only executes when triggered by events, and you only pay for CPU time and memory used during execution (versus a traditional web server where you are paying a fee even if your app is idle). This is called micro-billing, and is one key reason serverless computing is so powerful.

Curious about Azure Functions? Follow the link https://aka.ms/go-funcs to get up and running with your first function in minutes.

Scott Guthrie on the Azure Red Shirt Tour

In fact, micro-billing is so important, it’s one of three rules I use to verify if a service is serverless. There is not an official set of rules and there is no standard for serverless. The closest thing to a standard is the whitepaper published by the Cloud Native Computing Foundation titled CNCF WG-Serverless Whitepaper v1.0 (PDF). The paper describes serverless computing as “building and running applications that do not require server management.” The paper continues to state they are “executed, scaled, and billed in response to the exact demand needed at the moment.”

It’s easy to label almost everything serverless, but there is a difference between managed and serverless. A managed service takes care of responsibilities for you, such as standing up a website or hosting a Docker container. Serverless is a managed service but requires a bit more. Here is Jeremy’s Serverless Rules.

1. The service should be capable of running entirely in the cloud. Running locally is fine and often preferred for developing, testing, and debugging, but ultimately it should end up in the cloud.
2. You don’t have to configure a virtual machine or cluster. Docker is great, but containers require a Docker host to run. That host typically means setting up a VM and, for resiliency and scale, using an orchestrator like Kubernetes to scale the solution. There are also services like Azure Web Apps that provide a fully managed experience for running web apps and containers, but I don’t consider them serverless because they break the next rule.
3. You only pay for active invocations and never for idle time. This rule is important, and the essence of micro-billing. ACI is a great way to run a container, but I pay for it even when it’s not being used. A function, on the other hand, only bills when it’s called.

These rules are why I stopped calling managed databases “serverless.” So, what, then, does qualify as serverless?

The Azure serverless platform includes Azure Functions, Logic Apps, and Event Grid. In this post, we’ll take a closer look at Azure Functions.

Azure Functions

Azure Functions allows you to write code that is executed based on an event, or trigger. Triggers may include an HTTP request, a timer, a message in a queue, or any other number of important events. The code is passed details of the trigger but can also access bindings that make it easier to connect to resources like databases and storage. The serverless Azure Functions model is based on two parameters: invocations and gigabyte seconds.

Invocations are the number of times the function is invoked based on its trigger. Gigabyte seconds is a function of memory usage. Image a graph that shows time on the x-axis and memory consumption on the y-axis. Plot the memory usage of your function over time. Gigabyte seconds represent the area under the curve.

Let’s assume you have a microservice that is called every minute and takes one second to scan and aggregate data. It uses a steady 128 megabytes of memory during the run. Using the Azure Pricing Calculator, you’ll find that the cost is free. That’s because the first 400,000 Gigabyte seconds and 1 million invocations are free every month. Running every second (there are 2,628,000 seconds in a month) with double memory (256 megabytes), the entire monthly cost is estimated at $4.51.

Pricing calculator for Azure Functions

Recently I tweeted about my own experience with serverless cost (or lack thereof). I wrote a link-shortening tool. It uses a function to take long URLs and turn them into a shorter code I can easily share. I also have a function that takes the short code and performs the redirect, then stores the data in a queue. Another microservice processes items in the queue and stores metadata that I can analyze for later. I have tens of thousands of invocations per month and my total cost is less than a dollar.

A tweet about cost of running serverless code in Azure

Do I have your attention?

In future posts I will explore the cost model for Logic Apps and Event Grid. In the meantime…

Learn about and get started with your first Azure Function by following this link: https://aka.ms/go-funcs

I have never been good at pool, partly because I was never in reliable proximity of a pool table in my formative years. As I got older, it became easier to get a rack going as there seems to be one stuffed in the corner of every bar in America. These days, though, my pool agnosticism is a choice. Ultimately, I find easier ways to embarrass myself for the cost of any given game.

But Pocket-Run Pool has me rethinking my entire relationship with billiards. Since it graced my iPhone, I’ve YouTubed pool competitions. I’ve watched trick shot exhibitions. Zach Gage developed this game because he couldn’t find a pool app he liked. Unbeknownst to him, he introduced me to a new hobby.

I’m setting myself up for failure, because there’s something wholly unique about this pool experience. Gage has developed this knack for turning the puzzles in the back of your Sunday papers and those games that come pre-installed on your computer into this unbelievable concept that no one knew they needed.

Pocket-Run doesn’t dramatically change the concept of eight-ball, just as Flipflop Solitaire didn’t completely overhaul the classic procedures of Patience. You still rack up a triangle of balls and use a cue ball to knock them into pockets. Good players still think shots ahead, computing both how they will sink what’s in front of them, and where their cue will end up post shot to sink what’s left.

From there, the liberties start. Firstly, there are only ten balls with numbers spanning from 2 to 13, omitting 5 and 11. There’s no required order to sink these in, nor are there solid or stripe restrictions. Everything on the table, save for your cue ball, needs to find a pocket to call home. Maybe the biggest, most “a ha!” of changes, that make pool suddenly the most infatuating single player game ever, is that each pocket has a score multiplier.

When you sink a ball, it’ll get multiplied by the number the pocket shows, from a measly 1x to a mighty 10x. Every time you sink a ball, the pockets rotate clockwise. Now, not only are you trying to control the board based on ball contact, but also based on how you can anticipate the most valuable scores will be.

Every time you ‘scratch’ the cue ball, you’ll lose one of your three lives. Altogether, pool stops looking like an indoor sport, and takes more the form of a puzzle. It seems strange, considering his gameography, that he’d dabble in a parlour room game until you realize it’s just another way to sneak a brain-teaser into an unassuming entertainment staple.

The actual act of aiming and shooting is its own meta version of borrowing an established concept and tweaking it into something that makes too much sense. You rotate your cue by dragging your finger around the ball. An outline of your shot will project itself forward. When the ghostly ball makes contact with another ball, a smaller line will predict its path to a lesser degree. This secondary line gets bigger and smaller the most solid the impact with the cue ball, making your aim more or less accurate depending on the angle you choose to play it.

When it’s time to shoot, you tap one of the arrows and a cue pops in from the side. With a swipe of your finger, the cue thrusts, and the ball is let loose. How fast you swipe will determine how hard of a shot you produce. There’s no minute details like cue ball English to speak of here, which is a good and bad thing. You don’t have a great deal of control of how your cue ball moves after you shoot. You can’t reliably get it to stop on contact or manipulate it in different directions. Its absence does take the pressure off of you when shooting though. Not having to worry about all that stuff means you really just get to swipe and move on, letting the balls fall as they may.

The randomness doesn’t stop there. You have no control over the rack position during breaks. When your scratch, you have no control over where the ball goes. The latter can be devastating when you’re deep in a round of Standard Run, the game’s main mode. One scratch can put you out of position for a big score, and without the ability to try to influence your cue ball during your shot, any given exchange becomes a crap shoot. It’s possible to work around, if some of the outrageous scores on the leaderboard are to be trusted. A novice may have a hard time coping with that fact.

There are other, even more puzzle-y modes to try your hands at. The Break of the Week gives players a table of already arranged balls and tasks them with making the highest score possible with them. The static features and the endless re-playabilty make this one of the most engrossing parts of Pocket-Run. After a set a score, I’m always returning to try and find a new sequence to try and push it to the next level. Experimentation can lead to breakthroughs in your technique that can travel back to Standard Run.

Insta-Tournaments are like hyper versions of BotW. It begins with a pre-set break, but you only have one attempt to set your best score. Once you sink all balls, or run out of lives, that is your contribution to that rack. New Insta-Tournament racks spawn every few minutes, so you’ll always have a new chance to make a mark.

They spiciest mode in Pocket-Run is High Stakes, where you bet tokens that you’ll win your game. Your pay-out multiplier varies based on your score. Score less than 500 pts on the 1000 token table, and you’ll actually lose money. The variation doesn’t end there. After your break, you take a spin on a wheel that will further modify your game with crazy variables. Adding a time limit or randomly changing the sizes of your balls even further creases the game of pool into some happy perversion of it that I’m all in for.

Ironically, Pocket-Run Pool’s greatest trick is that it makes me wish I could regurgitate this in the physical world. I want to run down to my local watering hole, take the cues out of patrons hands, and show them that there’s been a better way to play this game the whole time, and it was right under our noses.

Epic have officially launched the first preview of the upcoming Unreal Engine 4.20.  Of course this is Unreal Engine so you can expect a swath of graphical improvements, but there are several other new features as well.  On of the key features of this release is Beta 1 of Niagra, their next generation programmable particle FX system.  There are multiple new LOD tools, blueprint bookmark support, the ability to export sequencer data in Final Cut Pro XML format and a switch to Visual Studio 2017 for the default C++ projects.

From the Epic blog announcement:

Included in Preview 1 are improvements to the proxy LOD tool, as highlighted in the May 17th livestream, many mobile improvements and optimizations we’ve made for Fortnite on iOS and Android, and early access to mixed reality capture. Niagara will be rolling out in early access, and you’ll also see a number of our GDC features, including the new cinematic depth of field and improved rendering features for digital humans at your disposal.

You can learn a great deal more about the specifics of this release on the Unreal forums, or watching the video below.  One of the major features in this release, Niagara, was heavily featured in this GDC talk, if you like me cannot get it to run but want to learn more.  As always this update is available in the Epic game launcher.  Also be forewarned, this is a preview release so don’t even think about using it in production!

[embedded content]

GameDev News Unreal

Meet the CHAOSS community and the tools used by several open source projects, communities, and engineering teams to track and analyze their development activities, communities health, diversity, risk, and value.

This conference will show CHAOSS updates, use cases, and hands-on workshops for developers, community managers, project managers, and anyone interested in measuring open source project health.

When recording sounds on a laptop — say for a simple first screencast — many users typically use the built-in microphone. However, these small microphones also capture a lot of background noise. In this quick tip, learn how to use Audacity in Fedora to quickly remove the background noise from audio files.

Installing Audacity

Audacity is an application in Fedora for mixing, cutting, and editing audio files. It supports a wide range of formats out of the box on Fedora — including MP3 and OGG. Install Audacity from the Software application.

If the terminal is more your speed, use the command:

sudo dnf install audacity

Import your Audio, sample background noise

After installing Audacity, open the application, and import your sound using the File > Import menu item. This example uses a sound bite from freesound.org to which noise was added:

Next, take a sample of the background noise to be filtered out. With the tracks imported, select an area of the track that contains only the background noise. Then choose Effect >  Noise Reduction from the menu, and press the Get Noise Profile button.

Filter the Noise

Next, select the area of the track you want to filter the noise from. Do this either by selecting with the mouse, or Ctrl + a to select the entire track. Finally, open the Effect > Noise Reduction dialog again, and click OK to apply the filter.

Additionally, play around with the settings until your tracks sound better. Here is the original file again, followed by the noise reduced track for comparison (using the default settings):

Since we launched Visual Studio 2017 in March of that year, it has become our most popular Visual Studio release ever. Your feedback has helped our team publish seven updates since our initial GA, which have improved solution load performance, build performance, and unit test discovery performance. We’ve also made Visual Studio 2017 our most accessible releases ever, helping developers with low-vision or no-vision be more productive.

Our team is focused on introducing features that make every developer more productive: better navigation features like “go to all” (Ctrl + ,), features to improve code quality like Live Unit Testing, and most recently, to enable real time collaboration with Live Share. And we have even started to show how we will use artificial intelligence to assist developers with IntelliCode.

Now, it’s time to start to look at what comes next.

The short answer is Visual Studio 2019

Because the Developer Tools teams (especially .NET and Roslyn) do so much work in GitHub, you’ll start to see check-ins that indicate that we’re laying the foundation for Visual Studio 2019, and we’re now in the early planning phase of Visual Studio 2019 and Visual Studio for Mac. We remain committed to making Visual Studio faster, more reliable, more productive for individuals and teams, easier to use, and easier to get started with. Expect more and better refactorings, better navigation, more capabilities in the debugger, faster solution load, and faster builds. But also expect us to continue to explore how connected capabilities like Live Share can enable developers to collaborate in real time from across the world and how we can make cloud scenarios like working with online source repositories more seamless. Expect us to push the boundaries of individual and team productivity with capabilities like IntelliCode, where Visual Studio can use Azure to train and deliver AI-powered assistance into the IDE.

Our goal with this next release is to make it a simple, easy upgrade for everyone – for example, Visual Studio 2019 previews will install side by side with Visual Studio 2017 and won’t require a major operating system upgrade.

As for timing of the next release, we’ll say more in the coming months, but be assured we want to deliver Visual Studio 2019 quickly and iteratively. We’ve learned a lot from the cadence we’ve used with Visual Studio 2017, and one of the biggest things we have learned is that we can do a lot of good work if we focus on continually delivering and listening to your feedback. There are no bits to preview yet, but the best way to ensure you are on the cutting edge will be to watch this blog and to subscribe to the Visual Studio 2017 Preview.

In the meantime, our team will continue to publish a roadmap of what we’re planning online, work in many open source repositories, and take your feedback through our Developer Community website. This blog post is just another example of sharing our plans with you early, so you can plan and work with us to continue to make Visual Studio a great coding environment.

John

John Montgomery, Director of Program Management for Visual Studio @JohnMont John is responsible for product design and customer success for all of Visual Studio, C++, C#, VB, JavaScript, and .NET. John has been at Microsoft for 17 years, working in developer technologies the whole time.