DEV Community: Craig Shoemaker

My git aliases

Craig Shoemaker — Mon, 18 Jul 2022 13:09:57 +0000

I'm lazy.

Every day I need to sync up branches in git to account for the following:

Changes made to the remote main branch
Changes made to the current branch from the origin

In looking for ways to make to some simple shortcuts, I found Nicolas Fränkel's blog post on Creating Git shortcuts and How to get the name of the current git branch into a variable in a shell script? to be particularly helpful.

By using the techniques described in each of these articles in concert, I have defind the following git aliases.

open

Opens the current folder in Visual Studio Code.

alias open="code ."

get-branch

Sets $branch as the current branch.

alias get-branch="branch=$(git branch | sed -n -e 's/^\* \(.*\)/\1/p')"

sync-branch

Pulls the branch set to $branch from the origin.

alias sync-branch="git pull origin $branch"

sync-main

Pulls the remote main branch into the current branch.

alias sync-main="git pull upstream main"

Refactor Node.js and Express APIs to Serverless - Free Workshop

Craig Shoemaker — Thu, 10 Sep 2020 18:05:05 +0000

Join us as we refactor an Express API to serverless architecture in this free hands-on workshop.

{
  topic: "Refactor Node.js and Express APIs to Serverless",
  date: "Sep 16, 2020",
  time: "8am PT/11am ET"
}

Watch broadcast here
Add calendar reminder: Outlook, iCal, Google Calendar

You'll learn to:

Refactor Node.js Express APIs to an Azure Functions application
Create a Functions app with TypeScript/JavaScript
Explore the differences and similarities between Express APIs and Azure Functions

Join Burke Holland, John Papa, and Craig Shoemaker for this FREE event by watching the stream (during broadcast hours), or set reminder on your calendar:

Bring you questions as we'll answering in real-time through YouTube chat.

If you want a head start, you make sure to check out these resources:

We'll see you there!

Create:Frontend: 5 Ways to Learn from This Event!

Craig Shoemaker — Tue, 28 Jul 2020 23:48:55 +0000

Want to do more with static web apps?

Join us at CREATE:Frontend on Jul 29 (8:30am PDT / 11:30am EDT) for a 4-hr free virtual event with 8 talks and a 90-minute hands-on workshop to jumpstart your static web apps journey

Bookmark our anchor post and do check back for updates

On July 29 we are running Create: Frontend, a virtual half-day event focused on learning and exploration for front-end developers.

The event is free and live-streamed, and features speakers and topics ranging from static websites and accessibility, to remoe work, inclusive design and visual storytelling. Here are 5 things you can do to get the most from the event.

1. Watch Sessions, Engage With Speakers!

You can find all the sessions here, on our anchor post.

Create:Frontend - Let's talk about static web apps!

theCatShepherd for Microsoft Azure ・ Jul 22 '20

#mscreate #javascript #webdev #frontend

We recommend you bookmark that page and revisit it later to get updates when on videos, resources and more.

Most talks are just 15 minutes long, but each has a dev.to page where we encourage you to post comments or ask questions.
Speakers will spend 15 minutes after their session on Q&A and take questions via these comments. Once the live Q&A is over, we will post an update on that page. Subsquent questions may be answered at the discretion (and availability) of speakers.

2. Attend the Hands-on Workshop!

Nothing helps you learn and use new ideas like a hands-on workshop. We've got a 90-minute session for you to dig in deep into building and deploying web apps with your favorite JavaScript framework. Learn more here and don't miss it!

Free Workshop on Azure Static Web Apps

John Papa for Microsoft Azure ・ Jul 22 '20

#react #angular #vue #staticwebapps

3. Follow the Azure Organization on dev.to!

Most of the speakers and moderators are members of the Azure Organization on dev.to. These include members from the Developer Relations teams and Product Groups.

Microsoft Azure Follow

Learn how to build and manage powerful applications using Microsoft Azure cloud services. Explore the documentation and samples, skill yourself up with tutorials and training. Any language. Any platform.

By following the organization, you can be notified of the latest content posted by the team, and get early notice about other such virtual events that we will run in the future.

4. Explore the Resources!

Want to continue your static web apps journey? We have you covered! Here are three places to start:

5. Watch the keynote!!

Yes, join Daria Grigoriu, and me, Craig Shoemaker, for the opening keynote as we kick off this event.

SESSION: July 29, 2020: 08:35 PDT - 08:50AM PDT
We share what's on the top of mind for frontend developers and the state of developers tools in 2020.

Craig ShoemakerFollow

I work for Microsoft on the Azure Static Web Apps & Azure Container Apps teams | Pluralsight author | Web Rush co-host | Musician https://bit.ly/the-ride-yt

And don't forget! Even though CREATE: Frontend is 100% virtual, we've made sure we still make personal connections:

Live Q&A: Engage in discussions with speakers and the community. Speakers will be online for about 15 minutes after their session.
Resources: After the event, check for additional slides, videos, and resources for this session including activity packs for kids

See you online!

Runtime binding with Azure Functions

Craig Shoemaker — Mon, 23 Sep 2019 23:32:33 +0000

This article is part of #ServerlessSeptember. You'll find other helpful articles, detailed tutorials, and videos in this all-things-Serverless content collection. New articles are published every day — that's right, every day — from community members and cloud advocates in the month of September.

Find out more about how Microsoft Azure enables your Serverless functions at https://docs.microsoft.com/azure/azure-functions/.

Serverless functions rarely work in isolation. Functions are often paired with other services like a database, a storage service, or perhaps even an email notification service. Azure Functions makes it easy to connect with these services by offering bindings that give you an out-of-the-box connection to an array of cloud services. You can achieve a lot using the standard configurations, but what if you need go beyond the defaults?

Suppose you want to:

Change a storage location depending on an incoming IP address?
Switch an email recipient based on a dev vs. production environment?
Write data to a different message queue based on a date range?

These are just a few examples of the type of adjustments which may be difficult using a binding's default settings. This article demonstrates how to configure a C# Azure Functions binding at run time to take full control over a binding's configuration.

tl;dr

To configure a binding at runtime:

Declare the binding parameter as a Binder or IBinder instance.
Create an instance of the binding attribute.
Customize the binding attribute as necessary.
Either use Bind or BindAsync to bind the attribute to a cloud service.
Use the binding

A working example is available on GitHub: azure-functions-runtime-binding.

Default binding

Before diving into the details of how runtime binding works, first consider the default scenario. The following code example implements an HTTP-triggered function that saves a message to an Azure Storage blob container.

[FunctionName("SaveDefault")]
public static IActionResult Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
    HttpRequest req,

    [Blob("messages/{sys.randguid}.txt", FileAccess.Write)] out string blob,
    ILogger log)
{
    string message = req.Query["message"];
    blob = $"Default binding: {message}";

    return new OkResult();
}

For the binding to work in this context, the blob parameter is set up in the following ways:

The Blob attribute is declared to write data mapped to a blob container named messages.
The {sys.randguid} replacement token ensures the new blob is given a unique name.
The parameter is declared as a string.
The parameter is declared as an out parameter. Using an out parameter gives the binding a chance to take the primitive string's value and use it to write out to the storage container elsewhere in the binding's logic.

This setup works great for simple scenarios. However, using this approach makes it difficult to make changes to the binding. In some cases you may want to:

Change the connection string.
Calculate the blob name and/or the container's name.
- You do have a few replacement tokens and route parameters available to influence the blob path, but some needs are more complex.
Dynamically change the file access type. Perhaps in some instances you want to create the attribute with Write or ReadWrite access levels.

To achieve more flexible binding customization, you can implement runtime binding.

Runtime binding

The final result of the following function is the same as implemented for the default scenario. The difference in this instance is that the binding is imperatively created, giving you the chance to affect a binding's behavior.

[FunctionName("SaveCustom")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
    HttpRequest req,
    IBinder binder,
    ILogger log)
{
    string message = req.Query["message"];

    var attribute = new BlobAttribute("messages/{sys.randguid}.txt", FileAccess.Write);
    attribute.Connection = "AzureStorageConnectionString";

    using(var blob = await binder.BindAsync<TextWriter>(attribute))
    {
        blob.Write($"Runtime binding: {message}");
    }

    return new OkResult();
}

The binding is declared as an IBinder type, which gives you the chance to determine the binding configuration.

In this scenario:

An instance of BlobAttribute is created by passing the same parameters to the constructor as shown in the default example.
- Here you could decide to use custom logic to determine the blob container name or generate a custom blob name.
The Connection property is set.
- Here you could swap out an app setting name depending on the environment or perhaps input to the function.
The blob binding is created by calling binder.BindAsync since the TextWriter class is used to write to the blob container.
Calling blob.Write is what eventually persists the data to the blob container.

NOTE: Instead of typing the binding as a string (as shown in the default scenario), the binding is created as a TextWriter. The TextWriter class is used because a string instance has no knowledge of how to write back to the blob container. The TextWriter is configured to know about the blob container through the call of binder.BindAsync.

Code sample

The sample code is available on GitHub: azure-functions-runtime-binding.

Summary

The built-in Azure Functions bindings give you rich access to a number of different cloud services. While the default behavior may work well in many cases, sometime you need the chance to customize a binding's configuration.

You can customize a binding at runtime via the following steps:

Declare the binding parameter as a Binder or IBinder instance.
Create an instance of the binding attribute.
Customize the binding attribute as necessary.
Either use Bind or BindAsync to bind the attribute to a cloud service.
Use the binding