There are a ton of options for hosting your SQL server on Azure. Each is slightly different so how can you know which one is right? We have some answers for that!
Show links
Elastic Query ep 190 - https://youtu.be/IAx1nsh5-Ao
We don’t always need a framework like React/Vue/Angular to add interactive behaviour to our web pages. The browser provides some handy features that can make it easy to add simple interactions. One example is the template element. Let’s take a look at how to use it to dynamically inject elements into a page.
Template Element - https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template
When it comes to performance, it’s important to test our assumptions. In today’s episode, David walks us through his failed attempt to optimize uploading files to blob storage. In this case, fewer allocations doesn’t translate to better performance because there’s a lot more going on inside BlockBlockClient’s OpenWriteAsync() method than we thought.
Previous Episode
Performance of .NET JSON Serialization (#242) - https://youtu.be/w7ZfEVC76ho
Writing a new GitHub Actions workflow and want to save the embarrassment of a dozen failed builds displayed prominently on GitHub? Well ACT is here to save you. Run your GitHub actions locally using the Act CLI. Get that workflow in a working state before pushing your code to GitHub.
That’s right folks! Locally sourced, artisanal workflows!
Compressing the body of requests isn’t done very commonly but if you’re sending a lot of data to the server from the front end it may be desirable to shrink it. In this episode we use pako (https://nodeca.github.io/pako/) to compress the body of a request reducing the size by 90%
Reference:
https://medium.com/axiomzenteam/put-your-http-requests-on-a-diet-3e1e52333014
Here we’re going to dive in to the classic ‘Lemonade Stand’ game and reimagine it as a whole new adventure in our cloud-based (and VR-based) world. Have ideas to share? What could be done to this app to make it waaaaaaaay over the top?
Check out the repo here: https://github.com/MisterJames/LemonadeStand
With the built in System.Text.Json serializer, serializing objects to and from JSON in .NET is FAST! However, the actual performance you get depends a bit on how you use it. Using DotNetBenchmark, we take a look at some different patterns that can be used for serializing an object to and from a file on disk.
Benchmarking in .NET: https://benchmarkdotnet.org/articles/overview.html
JSON Serialization: https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-how-to?pivots=dotnet-6-0
Mermaid allows for simple diagrams in Markdown and now it is supported on GitHub!
Mermaid docs: https://mermaid-js.github.io/mermaid/#/README
GitHub announcement: https://github.blog/2022-02-14-include-diagrams-markdown-files-mermaid/
Cover image Creative Commons:
https://www.maxpixel.net/Sea-Cartoon-Fantasy-Fish-Mirror-Mermaid-Siren-5542841
When it comes to durable functions, there’s no magic as to where your progress is tracked! In fact, you can even configure it as you see fit. In this episode we’ll look at how and where the data is stored to back your orchestrations and talk about a few preview packages that allow you to configure the persistence yourself.
In this episode, we take our quest to improve page load performance to the next level by introducing responsive WebP images. Using responsive images, we can minimize the number of bytes downloaded to render images by specifying different images that are more appropriately sized for different sizes of screens. Let’s take our mobile lighthouse score from 66 to 100!
Previous Episode:
Optimizing Web Images with WebP - https://youtu.be/nx4UHooI-is
Useful Links:
https://12daysofweb.dev/2021/image-display-elements/
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/picture
https://caniuse.com/?search=picture
https://caniuse.com/?search=webp