By Joe Robinson 10 Mar 2020

DOOM Eternal is set to be one of the biggest, baddest, brutalest(?) games coming to Switch this year, but even the mighty DOOM Slayer can’t say no to the cuddly cuteness of a unicorn.

That’s right, the upcoming sequel to 2016’s DOOM will allow you to use special in-game skins to customise your character as you please. When the game launches on other platforms on 20th March, players will be able to claim the ‘DOOMicorn Slayer Master Collection’ by linking their Bethesda account to their Twitch Prime account, which will grant them access all of this:

• ‘DOOMicorn’ Slayer Skin
• ‘Purple Pony’ Skin Variant
• ‘Night-mare’ Skin Variant
• ‘Magic Meadow’ Base Podium
• ‘For Those Who Dare to Dream!’ Maxed-Out Podium
• ‘Clip Clop’ Stance Animation
• ‘Haymaker’ Intro Animation
• ‘Horsing Around’ Victory Animation
• ‘Love Conquers All’ Player Icon
• ‘Super Sparkle Slayer’ Nameplate & Title

Now, it’s worth noting that the trailer above doesn’t include the Switch logo, although we’re confident this is relating to the 20th March release date for all of the items (thanks to the game’s delay). Therefore, we’d imagine Switch owners will also be allowed access to all of these goodies later down the line.

After all, there has to be an Isabelle exclusive costume for the Switch version, right? If you’re reading, Bethesda, we’ll only ask for 10% of the royalties!

Will you be strutting your stuff as the DOOMicorn? Let us know with a comment below.

A new preview update of Blazor WebAssembly is now available! Here’s what’s new in this release:

• Integration with ASP.NET Core static web assets
• Token-based authentication
• Improved framework caching
• Updated linker configuration
• Build Progressive Web Apps

Get started

To get started with Blazor WebAssembly 3.2.0 Preview 2 install the latest .NET Core 3.1 SDK.

NOTE: Version 3.1.102 or later of the .NET Core SDK is required to use this Blazor WebAssembly release! Make sure you have the correct .NET Core SDK version by running dotnet --version from a command prompt.

Once you have the appropriate .NET Core SDK installed, run the following command to install the update Blazor WebAssembly template:

dotnet new -i Microsoft.AspNetCore.Components.WebAssembly.Templates::3.2.0-preview2.20160.5

That’s it! You can find additional docs and samples on https://blazor.net.

Upgrade an existing project

To upgrade an existing Blazor WebAssembly app from 3.2.0 Preview 1 to 3.2.0 Preview 2:

• Update your package references and namespaces as described below:
  
  • Microsoft.AspNetCore.Blazor -> Microsoft.AspNetCore.Components.WebAssembly
  • Microsoft.AspNetCore.Blazor.Build -> Microsoft.AspNetCore.Components.WebAssembly.Build
  • Microsoft.AspNetCore.Blazor.DevServer -> Microsoft.AspNetCore.Components.WebAssembly.DevServer
  • Microsoft.AspNetCore.Blazor.Server -> Microsoft.AspNetCore.Components.WebAssembly.Server
  • Microsoft.AspNetCore.Blazor.HttpClient -> Microsoft.AspNetCore.Blazor.HttpClient (unchanged)
  • Microsoft.AspNetCore.Blazor.DataAnnotations.Validation -> Microsoft.AspNetCore.Components.DataAnnotations.Validation
  • Microsoft.AspNetCore.Blazor.Mono -> Microsoft.AspNetCore.Components.WebAssembly.Runtime
  • Mono.WebAssembly.Interop -> Microsoft.JSInterop.WebAssembly
• Update all Microsoft.AspNetCore.Components.WebAssembly.* package references to version 3.2.0-preview2.20160.5.
• In Program.cs add a call to builder.Services.AddBaseAddressHttpClient().
• Rename BlazorLinkOnBuild in your project files to BlazorWebAssemblyEnableLinking.
• If your Blazor WebAssembly app is hosted using ASP.NET Core, make the following updates in Startup.cs in your Server project:
  
  • Rename UseBlazorDebugging to UseWebAssemblyDebugging.
  • Remove the call to services.AddResponseCompression (response compression is now handled by the Blazor framework).
  • Replace the call to app.UseClientSideBlazorFiles<Client.Program>() with app.UseBlazorFrameworkFiles().
  • Replace the call to endpoints.MapFallbackToClientSideBlazor<Client.Program>("index.html") with endpoints.MapFallbackToFile("index.html").

Hopefully that wasn’t too painful!

Integration with ASP.NET Core static web assets

Blazor WebAssembly apps now integrate seamlessly with how ASP.NET Core handles static web assets. Blazor WebAssembly apps can use the standard ASP.NET Core convention for consuming static web assets from referenced projects and packages: _content/{LIBRARY NAME}/{path}. This allows you to easily pick up static assets from referenced component libraries and JavaScript interop libraries just like you can in a Blazor Server app or any other ASP.NET Core web app.

Blazor WebAssembly apps are also now hosted in ASP.NET Core web apps using the same static web assets infrastructure. After all, a Blazor WebAssembly app is just a bunch of static files!

This integration simplifies the startup code for ASP.NET Core hosted Blazor WebAssembly apps and removes the need to have an assembly reference from the server project to the client project. Only the project reference is needed, so setting ReferenceOutputAssembly to false for the client project reference is now supported.

Building on the static web assets support in ASP.NET Core also enables new scenarios like hosting ASP.NET Core hosted Blazor WebAssembly apps in Docker containers. In Visual Studio you can add docker support to your Blazor WebAssembly app by right-clicking on the Server project and selecting Add > Docker support.

Token-based authentication

Blazor WebAssembly now has built-in support for token-based authentication.

Blazor WebAssembly apps are secured in the same manner as Single Page Applications (SPAs). There are several approaches for authenticating users to SPAs, but the most common and comprehensive approach is to use an implementation based on the OAuth 2.0 protocol, such as OpenID Connect (OIDC). OIDC allows client apps, like a Blazor WebAssembly app, to verify the user identity and obtain basic profile information using a trusted provider.

Using the Blazor WebAssembly project template you can now quickly create apps setup for authentication using:

• ASP.NET Core Identity and IdentityServer
• An existing OpenID Connect provider
• Azure Active Directory

Authenticate using ASP.NET Core Identity and IdentityServer

Authentication for Blazor WebAssembly apps can be handled using ASP.NET Core Identity and IdentityServer. ASP.NET Core Identity handles authenticating users while IdentityServer handles the necessary protocol endpoints.

To create a Blazor WebAssembly app setup with authentication using ASP.NET Core Identity and IdentityServer run the following command:

dotnet new blazorwasm --hosted --auth Individual -o BlazorAppWithAuth1

If you’re using Visual Studio, you can create the project by selecting the “ASP.NET Core hosted” option and the selecting “Change Authentication” > “Individual user accounts”.

Run the app and try to access the Fetch Data page. You’ll get redirected to the login page.

Register a new user and log in. You can now access the Fetch Data page.

The Server project is configured to use the default ASP.NET Core Identity UI, as well as IdentityServer, and JWT authentication:

// Add the default ASP.NET Core Identity UI

services.AddDefaultIdentity<ApplicationUser>(options => options.SignIn.RequireConfirmedAccount = true) .AddEntityFrameworkStores<ApplicationDbContext>(); // Add IdentityServer with support for API authorization

services.AddIdentityServer() .AddApiAuthorization<ApplicationUser, ApplicationDbContext>(); // Add JWT authentication

services.AddAuthentication() .AddIdentityServerJwt();

The Client app is registered with IdentityServer in the appsettings.json file:

"IdentityServer": { "Clients": { "BlazorAppWithAuth1.Client": { "Profile": "IdentityServerSPA" } }

},

In the Client project, the services needed for API authorization are added in Program.cs:

builder.Services.AddApiAuthorization();

In FetchData.razor the IAccessTokenProvider service is used to acquire an access token from the server. The token may be cached or acquired without the need of user interaction. If acquiring the token succeeds, it is then applied to the request for weather forecast data using the standard HTTP Authorization header. If acquiring the token silently fails, the user is redirected to the login page:

protected override async Task OnInitializedAsync()

{ var httpClient = new HttpClient(); httpClient.BaseAddress = new Uri(Navigation.BaseUri); var tokenResult = await AuthenticationService.RequestAccessToken(); if (tokenResult.TryGetToken(out var token)) { httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {token.Value}"); forecasts = await httpClient.GetJsonAsync<WeatherForecast[]>("WeatherForecast"); } else { Navigation.NavigateTo(tokenResult.RedirectUrl); }

}

For additional details on using Blazor WebAssembly with ASP.NET Core Identity and IdentityServer see Secure an ASP.NET Core Blazor WebAssembly hosted app with Identity Server

Authenticate using an existing OpenID Connect provider

You can setup authentication for a standalone Blazor WebAssembly using any valid OIDC provider. Once you’ve registered your app with the OIDC provider you configure the Blazor WebAssembly app to use that provider by calling AddOidcAuthentication in Program.cs:

builder.Services.AddOidcAuthentication(options =>

{ options.ProviderOptions.Authority = "{AUTHORITY}"; options.ProviderOptions.ClientId = "{CLIENT ID}";

});

You can create a standalone Blazor WebAssembly app that uses a specific OIDC provider for authentication using the following command:

dotnet new blazorwasm --auth Individual --client-id "{CLIENT ID}" --authority "{AUTHORITY}"

For more details on configuring authentication for a standalone Blazor WebAssembly app see Secure an ASP.NET Core Blazor WebAssembly standalone app with the Authentication library

Authenticate using Azure AD & Azure AD B2C

You can also setup Blazor WebAssembly apps to use Azure Active Directory (Azure AD) or Azure Active Directory Business-to-Customer (Azure AD B2C) for authentication. When authenticating using Azure AD or Azure AD B2C authentication is handled using the new Microsoft.Authentication.WebAssembly.Msal library, which is based on the Microsoft Authentication Library (MSAL.js).

To learn how to setup authentication for Blazor WebAssembly app using Azure AD or Azure AD B2C see:

Additional authentication resources

This is just a sampling of the new authentication capabilities in Blazor WebAssembly. To learn more about how Blazor WebAssembly supports authentication see Secure ASP.NET Core Blazor WebAssembly.

Improved framework caching

If you look at the network trace of what’s being download for a Blazor WebAssembly app after it’s initially loaded, you might think that Blazor WebAssembly has been put on some sort of extreme diet:

Whoa! Only 159kB? What’s going on here?

When a Blazor WebAssembly app is initially loaded, the runtime and framework files are now stored in the browser cache storage:

When the app loads, it first uses the contents of the blazor.boot.json to check if it already has all of the runtime and framework files it needs in the cache. If it does, then no additional network requests are necessary.

You can still see what the true size of the app is during development by checking the browser console:

Updated linker configuration

You may notice with this preview release that the download size of the app during development is now a bit larger, but build times are faster. This is because we no longer run the .NET IL linker during development to remove unused code. In previous Blazor previews we ran the linker on every build, which slowed down development. Now we only run the linker for release builds, which are typically done as part of publishing the app. When publishing the app with a release build (dotnet publish -c Release), the linker removes any unnecessary code and the download size is much more reasonable (~2MB for the default template).

If you prefer to still run the .NET IL linker on each build during development, you can turn it on by adding <BlazorWebAssemblyEnableLinking>true<BlazorWebAssemblyEnableLinking> to your project file.

Build Progressive Web Apps with Blazor

A Progressive Web App (PWA) is a web-based app that uses modern browser APIs and capabilities to behave like a native app. These capabilities can include:

• Working offline and always loading instantly, independently of network speed
• Being able to run in its own app window, not just a browser window
• Being launched from the host operating system (OS) start menu, dock, or home screen
• Receiving push notifications from a backend server, even while the user is not using the app
• Automatically updating in the background

A user might first discover and use the app within their web browser like any other single-page app (SPA), then later progress to installing it in their OS and enabling push notifications.

Blazor WebAssembly is a true standards-based client-side web app platform, so it can use any browser API, including the APIs needed for PWA functionality.

Using the PWA template

When creating a new Blazor WebAssembly app, you’re offered the option to add PWA features. In Visual Studio, the option is given as a checkbox in the project creation dialog:

If you’re creating the project on the command line, you can use the --pwa flag. For example,

dotnet new blazorwasm --pwa -o MyNewProject

In both cases, you’re free to also use the “ASP.NET Core hosted” option if you wish, but don’t have to do so. PWA features are independent of how the app is hosted.

Installation and app manifest

When visiting an app created using the PWA template option, users have the option to install the app into their OS’s start menu, dock, or home screen.

The way this option is presented depends on the user’s browser. For example, when using desktop Chromium-based browsers such as Edge or Chrome, an Add button appears within the address bar:

On iOS, visitors can install the PWA using Safari’s Share button and its Add to Homescreen option. On Chrome for Android, users should tap the Menu button in the upper-right corner, then choose Add to Home screen.

Once installed, the app appears in its own window, without any address bar.

To customize the window’s title, color scheme, icon, or other details, see the file manifest.json in your project’s wwwroot directory. The schema of this file is defined by web standards. For detailed documentation, see https://developer.mozilla.org/en-US/docs/Web/Manifest.

Offline support

By default, apps created using the PWA template option have support for running offline. A user must first visit the app while they are online, then the browser will automatically download and cache all the resources needed to operate offline.

Important: Offline support is only enabled for published apps. It is not enabled during development. This is because it would interfere with the usual development cycle of making changes and testing them.

Warning: If you intend to ship an offline-enabled PWA, there are several important warnings and caveats you need to understand. These are inherent to offline PWAs, and not specific to Blazor. Be sure to read and understand these caveats before making assumptions about how your offline-enabled app will work.

To see how offline support works, first publish your app, and host it on a server supporting HTTPS. When you visit the app, you should be able to open the browser’s dev tools and verify that a Service Worker is registered for your host:

Additionally, if you reload the page, then on the Network tab you should see that all resources needed to load your page are being retrieved from the Service Worker or Memory Cache:

This shows that the browser is not dependent on network access to load your app. To verify this, you can either shut down your web server, or instruct the browser to simulate offline mode:

Now, even without access to your web server, you should be able to reload the page and see that your app still loads and runs. Likewise, even if you simulate a very slow network connection, your page will still load almost immediately since it’s loaded independently of the network.

To learn more about building PWAs with Blazor, check out the documentation.

Known issues

There are a few known issues with this release that you may run into:

• When building a Blazor WebAssembly app using an older .NET Core SDK you may see the following build error:

  error MSB4018: The "ResolveBlazorRuntimeDependencies" task failed unexpectedly.
  error MSB4018: System.IO.FileNotFoundException: Could not load file or assembly '\BlazorApp1\obj\Debug\netstandard2.1\BlazorApp1.dll'. The system cannot find the file specified.
  error MSB4018: File name: '\BlazorApp1\obj\Debug\netstandard2.1\BlazorApp1.dll' error MSB4018: at System.Reflection.AssemblyName.nGetFileInformation(String s)
  error MSB4018: at System.Reflection.AssemblyName.GetAssemblyName(String assemblyFile)
  error MSB4018: at Microsoft.AspNetCore.Components.WebAssembly.Build.ResolveBlazorRuntimeDependencies.GetAssemblyName(String assemblyPath)
  error MSB4018: at Microsoft.AspNetCore.Components.WebAssembly.Build.ResolveBlazorRuntimeDependencies.ResolveRuntimeDependenciesCore(String entryPoint, IEnumerable`1 applicationDependencies, IEnumerable`1 monoBclAssemblies)
  error MSB4018: at Microsoft.AspNetCore.Components.WebAssembly.Build.ResolveBlazorRuntimeDependencies.Execute()
  error MSB4018: at Microsoft.Build.BackEnd.TaskExecutionHost.Microsoft.Build.BackEnd.ITaskExecutionHost.Execute()
  error MSB4018: at Microsoft.Build.BackEnd.TaskBuilder.ExecuteInstantiatedTask(ITaskExecutionHost taskExecutionHost, TaskLoggingContext taskLoggingContext, TaskHost taskHost, ItemBucket bucket, TaskExecutionMode howToExecuteTask)
  

  To address this issue, upgrade to version 3.1.102 or later of the .NET Core 3.1 SDK.

• You may see the following warning when building from the command-line:

  CSC : warning CS8034: Unable to load Analyzer assembly C:\Users\user\.nuget\packages\microsoft.aspnetcore.components.analyzers\3.1.0\analyzers\dotnet\cs\Microsoft.AspNetCore.Components.Analyzers.dll : Assembly with same name is already loaded
  

  This issue will be fixed in a future update to the .NET Core SDK. To workaround this issue, add the <DisableImplicitComponentsAnalyzers>true</DisableImplicitComponentsAnalyzers> property to the project file.

Feedback

We hope you enjoy the new features in this preview release of Blazor WebAssembly! Please let us know what you think by filing issues on GitHub.

Thanks for trying out Blazor!

 

By Amber Neely
Tuesday, March 10, 2020, 07:31 pm PT (10:31 pm ET)

Apple will attend a White House conference alongside other tech industry giants to coordinate responses to the COVID-19 outbreak.

Representatives from major tech companies are planning on attending a meeting at the White House hosted by U.S. Chief Technology Officer Michael Kratsios. The conference hopes to tackle how the federal government and the tech industry can work together in the face of the coronavirus outbreak.

Apple, Google, Amazon, Microsoft, and Twitter will all likely attend, either in-person or through teleconference, according to a spokesperson for the Office of Science and Technology Policy, said Politico.

COVID-19 continues to spread across the U.S., with nearly 1,000 cases as of Tuesday evening. Apple has already taken measures to help prevent the spread of COVID-19, both at Apple campuses and Apple retail locations.

Apple is offering hourly workers and retail employees unlimited sick leave if they exhibit symptoms of the virus, which could be instrumental in preventing the spread to customers.

Apple has also placed restrictions on employee travel to Italy and South Korea after cases of COVID-19 jumped in those countries. All non-essential travel to COVID-19 hotspots has been restricted, and a company vice president must approve business-critical travel.

It’s also increasingly likely that WWDC will be cancelled. A new order has been issued by the County of Santa Clara Public Health Department, explicitly banning mass gatherings for at least three weeks, as the county gathers more information about COVID-19. While technically not forbidden yet, a three-week delay is not a promising sign for the live event to happen on-schedule.

In honor of International Women’s Day, Microsoft is proud to recognize some of the amazing women of Microsoft Quantum. These engineers, scientists, program managers and business leaders are working toward realizing Microsoft’s mission of building a scalable quantum computer and global quantum community to help solve some of the world’s most challenging problems.

Last year, we introduced you to some of the women working on quantum software; this year we’re profiling more women delivering impact in the Microsoft Quantum program, across quantum hardware, software, partnerships, and business development.

This is the second of a two-part series. In case you missed it, meet The Women of Microsoft Quantum in Part 1.

Sydney Schreppler – Quantum Hardware Engineer

Q: Tell us more about your role in the Microsoft Quantum group. What exciting things are you working on right now?

I am a Quantum Engineer working as part of a global hardware team that characterizes quantum materials for the development of our topological qubit technology. Our team measures electrical transport properties in cryogenic environments, probing the quantum nature of the materials. Right now I’m excited to be working in Redmond, where, together with the Quantum Systems team, we span Microsoft’s full quantum stack, from our topological qubit layer at the very bottom all the way up to the algorithms offered in Azure Quantum.

Q: What was it that attracted you to the technology field? How and why did you decide to join the domain of quantum computing?

Long before I knew I wanted to study physics, people around me seemed to know it. I think it was because I was always asking for simple explanations for how the world worked and because I liked to understand those answers through a mathematical lens. Once I started studying physics, the more I learned, the simpler and more elegant the explanations got.

What attracted me to quantum measurements first, and later to quantum computing, was the idea that something that seemed so non-intuitive and mysterious was nonetheless observable, and even useful! I wanted to see quantum effects for myself, so as a college student, I sought out opportunities in labs measuring quantum things. And once I had “seen” quantum, I was hooked. I measured the quantum mechanical motion of tiny membranes, the interaction of ultracold atoms with laser light (obtaining my Ph.D. in physics along the way), and the quantum entanglement of superconducting circuits. Now at Microsoft, I get to harness these same kinds of measurements to develop our quantum hardware.

Amrita Singh – Quantum Hardware Engineer

Q: Tell us more about your role in the Microsoft Quantum group. What exciting things are you working on right now?

I am a hardware engineer and coordinate the substrate fabrication activities with a small team of nanofabrication engineers at Microsoft Quantum Labs – Delft. We engineer the substrates and create a platform for selective area growth of a high-quality III-V semiconductor/ superconductor hybrid network, which is a building block of the topological quantum qubit.

Q: What was it that attracted you to the technology field? How and why did you decide to join the domain of quantum computing?

I was born and raised in a remote rural village in northern India where a girl’s education wasn’t important and the only expectation from a girl was to get married at an early age, raise children, and at the most, become a primary school teacher in the village. Mathematics and Science were considered to be boys’ subjects and weren’t even available as an option until the senior year at my all-girls school when I started. I was fortunate though, in that they were introduced a year before I reached my final year.

I studied science in my school to prove my worthiness as much as the boys in the neighborhood, but didn’t fully believe in it because it conflicted with my belief in God and other superstitions. But I always loved mathematics because of its precision, as no belief could justify 2+2≠4.

My exposure to technology was very limited and I had my first encounter with computers during my Masters (Physics) degree at IIT Delhi. During my Ph.D. in Experimental Condensed Matter Physics, I started appreciating the power of scientific attitude when I would verify a hypothesis with experimental data. Being an experimental physicist, I would feel restless for my blind faith and that is when I started to question my deep-rooted superstitions and religious beliefs, getting rid of them over the course of about four to five years. This was only possible due to my career choice in Science and Technology and it has shaped me into who I am today.

I did my Ph.D. on quantum devices for spintronic application and I extended my knowledge to superconducting spintronics during my postdoc work at Leiden University, where I gained expertise in interface engineering for hybrid quantum devices. I believed that, with my diverse background in quantum physics and device engineering, I would be able to contribute toward the realization of an ambitious topological quantum computer at Microsoft, as well as be able to learn and grow without limit by working with great minds.

Science for me is not just a profession but a way of living. I strongly believe that we could change the lives of millions of unprivileged deserving children in the world by giving quality education and bring them into the mainstream by using technologies.

Aarthi Meenakshi Sundaram – Researcher

Q: Tell us more about your role in the Microsoft Quantum group. What exciting things are you working on right now?

I am a postdoctoral researcher in the Research and Applications team at Microsoft Quantum, where my overarching goal is to understand both the power and limitations of using quantum computers to solve some of our most challenging problems. Sometimes, this means defining efficient quantum algorithms for various problems. Other times, this means defining a mathematically rigorous computational model and analyzing which problems are “easy” or “difficult” in this model à la complexity theory.

Currently, I am looking forward to tackling both aspects in the context of quantum machine learning. It’s a nascent but rapidly evolving area with new algorithms being discovered and comes with its own set of challenges for us to understand precisely what kinds of learning problems can be sped up with quantum resources and to what extent. In classical computational learning theory, there are many well-established models of learning. Inevitably, we find that there may be various ways to “quantize” these models (i.e., add some “quantum magic” to these models, and each way could be useful in vastly different scenarios – some abstract/mathematical, some very real and even implementable in the near-term on quantum computers! Investigating these in all their variations is what excites me right now.

On a slightly different track, I also care about building tools that could help to efficiently verify quantum programs – through type checking or other methods. One of the main challenges is that any quantum program debugger that observes or measures how a quantum state is manipulated in the program could destroy the quantum nature of the state itself. Another challenge is that certain techniques that work well on small quantum programs will scale badly with the size of our program and could take too long to verify realistically. So, along with my collaborators here, we are investigating ways to build efficient type checkers that could provide us with the ability to verify some, if not all of the properties of interest in a quantum program.

Q: What was it that attracted you to the technology field? How and why did you decide to join the domain of quantum computing?

I have been reliably informed by my mother that, as a 4- or 5-year old, I took great joy in sitting on her lap and helping her with her programming work by entering the programs into our computer at home and marveling at this new object that knew how to follow my orders (or throw error messages!) So, while I don’t remember ever having to make a conscious choice to work in the world of computing, it has always seemed like a foregone conclusion in my mind, leading to my Math and Computer Science majors during undergrad.

For the first time at my university, one of my professors offered a course in quantum information and computing. I had just started getting interested in cryptography then and being introduced to this new computing model that could break state-of-the-art cryptosystems was a revelation! I was intrigued by this field that almost sounded like something out of science fiction and seemed so counterintuitive, at first.

Encouraged by my professor to pursue it beyond that one course, it was a natural progression for me to eventually pursue a Ph.D. in quantum complexity theory. It allowed me to blend the skills I had learned from both of my undergrad majors seamlessly. Being interested in the more abstract and theoretical aspects of computer science, I spent my Ph.D. analyzing the power of quantum analogs of various computational models. A continuous inspiration since I’ve delved more into quantum computing is that by living at the intersection and cutting edge of many different fields, one gets to work and learn from people whose expertise is vastly different than your own. With Microsoft Quantum’s aim of delivering a full stack of quantum services, that means, I am thrilled for the opportunity to interact with everyone from material scientists to mathematicians within the team.

Judith Suter – Senior Researcher

Q: Tell us more about your role in the Microsoft Quantum group. What exciting things are you working on right now?

In my work as a Senior Researcher in the Microsoft Quantum Hardware Program, I focus mainly on electrical characterization of different device types, materials, and fabrication processes. My days revolve around planning and designing experiments, running and optimizing low-temperature measurements, and exploring the resulting aggregated data. As part of a global team, another element of my job is cross-site collaboration where we leverage the diverse expertise of the whole team to collectively tackle challenging projects.

Recently I also became part of the Azure Hardware Systems and Infrastructure Diversity and Inclusion Council, where I represent the Quantum Hardware Program. I am excited to help drive the efforts towards the ambitious goals of Microsoft to fuel systemic change, widen our pipelines to reach and engage a diverse group of people, and transform our culture to ensure that everyone feels welcome and valued.

Q: What was it that attracted you to the technology field? How and why did you decide to join the domain of quantum computing?

My path to working on quantum computing was not without detours. As a high school student, I was fascinated by surrealist painters and the strange but self-consistent worlds they portrayed, so I commenced my studies at an arts and graphic design academy. Eventually, I left, longing to do something completely different, something I knew nothing about. I signed up for an undergraduate degree in Nanoscience, where I felt I could get a taste of different scientific fields. There, quantum physics intrigued me from the start: counterintuitive concepts born out of creative boldness – surprisingly, some lectures ended up reminding me of my art classes studying surrealism. I was hooked. I bought a one-way ticket to the epicenter of quantum physics, the Niels Bohr Institute in Copenhagen, joined Prof. Charles Marcus’ lab there at the Center for Quantum Devices and started my training to become a quantum physicist.

Vicky Svidenko – Partner Quantum Data Sciences

Q: Tell us more about your role in the Microsoft Quantum group. What exciting things are you working on right now?

I am leading the Quantum Systems Integration team – helping to accelerate quantum research and development. The Microsoft Quantum group is exploring ways to build a full-stack quantum computer and has become the world’s center of expertise on topological quantum computing. I am incredibly humbled by the opportunity to support this development effort and contribute to the new breakthroughs, together with an amazing team of talented researchers and engineers.

Q: What was it that attracted you to the technology field? How and why did you decide to join the domain of quantum computing?

I came to Quantum because I enjoy the loosely orchestrated chaos of early product development and the frenzy of excitement for every new learning and every new benchmark. I like that incredible sensation of being part of something futuristically amazing, now evolving and materializing.

Another reason: This was my first opportunity to work for an amazing female manager – Krysta Svore – and I wasn’t going to miss it.

Meet more of The Women of Microsoft Quantum in Part 1 of this series.

This is just a small sample of the amazing people on the Microsoft Quantum team. If you want to join us as we build the quantum future, we’re hiring!

Quarkus is a framework for Java development that is described on their web site as:

Silverblue — a Fedora Workstation variant with a container based workflow central to its functionality — should be an ideal host system for the Quarkus framework.

There are currently two ways to use Quarkus with Silverblue. It can be run in a pet container such as Toolbox/Coretoolbox. Or it can be run directly in a terminal emulator. This article will focus on the latter method.

Why Quarkus

According to Quarkus.io: “Quarkus has been designed around a containers first philosophy. What this means in real terms is that Quarkus is optimized for low memory usage and fast startup times.” To achieve this, they employ first class support for Graal/Substrate VM, build time Metadata processing, reduction in reflection usage, and native image preboot. For details about why this matters, read Container First at Quarkus.

Prerequisites

A few prerequisites will need to configured before you can start using Quarkus. First, you need an IDE of your choice. Any of the popular ones will do. VIM or Emacs will work as well. The Quarkus site provides full details on how to set up the three major Java IDE’s (Eclipse, Intellij Idea, and Apache Netbeans). You will need a version of JDK installed. JDK 8, JDK 11 or any distribution of OpenJDK is fine. GrallVM 19.2.1 or 19.3.1 is needed for compiling down to native. You will also need Apache Maven 3.53+ or Gradle. This article will use Maven because that is what the author is more familiar with. Use the following command to layer Java 11 OpenJDK and Maven onto Silverblue:

$ rpm-ostree install java-11-openjdk* maven

Alternatively, you can download your favorite version of Java and install it directly in your home directory.

After rebooting, configure your JAVA_HOME and PATH environment variables to reference the new applications. Next, go to the GraalVM download page, and get GraalVM version 19.2.1 or version 19.3.1 for Java 11 OpenJDK. Install Graal as per the instructions provided. Basically, copy and decompress the archive into a directory under your home directory, then modify the PATH environment variable to include Graal. You use it as you would any JDK. So you can set it up as a platform in the IDE of your choice. Now is the time to setup the native image if you are going to use one. For more details on setting up your system to use Quarkus and the Quarkus native image, check out their Getting Started tutorial. With these parts installed and the environment setup, you can now try out Quarkus.

Bootstrapping

Quarkus recommends you create a project using the bootstrapping method. Below are some example commands entered into a terminal emulator in the Gnome shell on Silverblue.

$ mvn io.quarkus:quarkus-maven-plugin:1.2.1.Final:create \ -DprojectGroupId=org.jakfrost \ -DprojectArtifactId=silverblue-logo \ -DclassName="org.jakfrost.quickstart.GreetingResource" \ -Dpath="/hello"

$ cd silverblue-logo

The bootstrapping process shown above will create a project under the current directory with the name silverblue-logo. After this completes, start the application in development mode:

$ ./mvnw compile quarkus:dev

With the application running, check whether it responds as expected by issuing the following command:

$ curl -w '\n' http://localhost:8080/hello

The above command should print hello on the next line. Alternatively, test the application by browsing to http://localhost:8080/hello with your web browser. You should see the same lonely hello on an otherwise empty page. Leave the application running for the next section.

Injection

Open the project in your favorite IDE. If you are using Netbeans, simply open the project directory where the pom.xml file resides. Now would be a good time to have a look at the pom.xml file.

Quarkus uses ArC for its dependency injection. ArC is a dependency of quarkus-resteasy, so it is already part of the core Quarkus installation. Add a companion bean to the project by creating a java class in your IDE called GreetingService.java. Then put the following code into it:

import javax.enterprise.context.ApplicationScoped; @ApplicationScoped

public class GreetingService { public String greeting(String name) { return "hello " + name; } }

The above code is a verbatim copy of what is used in the injection example in the Quarkus Getting Started tutorial. Modify GreetingResource.java by adding the following lines of code:

import javax.inject.Inject;

import org.jboss.resteasy.annotations.jaxrs.PathParam; @Inject GreetingService service;//inject the service @GET //add a getter to use the injected service @Produces(MediaType.TEXT_PLAIN) @Path("/greeting/{name}") public String greeting(@PathParam String name) { return service.greeting(name); }

If you haven’t stopped the application, it will be easy to see the effect of your changes. Just enter the following curl command:

$ curl -w '\n' http://localhost:8080/hello/greeting/Silverblue

The above command should print hello Silverblue on the following line. The URL should work similarly in a web browser. There are two important things to note:

1. The application was running and Quarkus detected the file changes on the fly.
2. The injection of code into the app was very easy to perform.

The native image

Next, package your application as a native image that will work in a podman container. Exit the application by pressing CTRL-C. Then use the following command to package it:

$ ./mvnw package -Pnative -Dquarkus.native.container-runtime=podman

Now, build the container:

$ podman build -f src/main/docker/Dockerfile.native -t silverblue-logo/silverblue-logo

Now run it with the following:

$ podman run -i --rm -p 8080:8080 localhost/silverblue-logo/silverblue-logo

To get the container build to successfully complete, it was necessary to copy the /target directory and contents into the src/main/docker/ directory. Investigation as to the reason why is still required, and though the solution used was quick and easy, it is not an acceptable way to solve the problem.

Now that you have the container running with the application inside, you can use the same methods as before to verify that it is working.

Point your browser to the URL http://localhost:8080/ and you should get a index.html that is automatically generated by Quarkus every time you create or modify an application. It resides in the src/main/resources/META-INF/resources/ directory. Drop other HTML files in this resources directory to have Quarkus serve them on request.

For example, create a file named logo.html in the resources directory containing the below markup:

<!DOCTYPE html>

<!--

To change this license header, choose License Headers in Project Properties.

To change this template file, choose Tools | Templates

and open the template in the editor.

-->

<html> <head> <title>Silverblue</title> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> </head> <body> <div> <img src="fedora-silverblue-logo.png" alt="Fedora Silverblue"/> </div> </body>

</html>

Next, save the below image alongside the logo.html file with the name fedora-silverblue-logo.png:

Now view the results at http://localhost:8080/logo.html.

Testing your application

Quarkus supports junit 5 tests. Look at your project’s pom.xml file. In it you should see two test dependencies. The generated project will contain a simple test, named GreetingResourceTest.java. Testing for the native file is only supported in prod mode. However, you can test the jar file in dev mode. These tests are RestAssured, but you can use whatever test library you wish with Quarkus. Use Maven to run the tests:

$ ./mvnw test

More details can be found in the Quarkus Getting Started tutorial.

Further reading and tutorials

Quarkus has an extensive collection of tutorials and guides. They are well worth the time to delve into the breadth of this microservices framework.

Quarkus also maintains a publications page that lists some very interesting articles on actual use cases of Quarkus. This article has only just scratched the surface of the topic. If what was presented here has piqued your interest, then follow the above links for more information.

Fixes a few bugs

• 
• by Liam Doolan 4 hours ago

Switch owners might not be getting their hands on DOOM Eternal later this month, but they’ll at least be able to relive the hellish Nintendo 64 title DOOM 64 for just $4.99 / £3.99 (or the regional equivalent). If the game itself wasn’t already enough, Nightdive Studios – the talented team behind this port – have revealed the re-release will also come with an entirely new chapter, during an interview with our friends at US Gamer.

Here’s exactly what senior developer James Haley had to say:

On our end, persistent players will have the opportunity to unlock a new chapter in the Doomguy’s saga, taking place shortly after [Doom 64’s] original campaign concludes. The Mother Demon you defeated in that outing had a sister, and since you’ve been messing up Hell non-stop, she tries to get rid of you by sending you away. If you can make your way back and take revenge, you’ll be rewarded with a bit of lore that fans of both series, new and classic, should enjoy.

So, there you go – once you defeat The Mother Demon, you’ll have to take on her sister. You’ll even get a little bit of extra lore after this as a reward. Are you as excited as we are about the release of DOOM 64 on the Switch? Leave a comment below.