DEV Community: Renee Noble

Get started with GitHub Copilot CLI: A free, hands-on course

Renee Noble — Thu, 05 Mar 2026 04:44:08 +0000

GitHub Copilot has grown well beyond code completions in your editor. It now lives in your terminal, too. GitHub Copilot CLI lets you review code, generate tests, debug issues, and ask questions about your projects without ever leaving the command line.

To help developers get up to speed, we put together a free, open source course: GitHub Copilot CLI for Beginners. It’s 8 chapters, hands-on from the start, and designed so you can go from installation to building real workflows in a few hours. Already have a GitHub account? GitHub Copilot CLI works with GitHub Copilot Free, which is available to all personal GitHub accounts.

In this post, I’ll walk through what the course covers and how to get started.

What GitHub Copilot CLI can do

If you haven’t tried it yet, GitHub Copilot CLI is a conversational AI assistant that runs in your terminal. You point it at files using @ references, and it reads your code and responds with analysis, suggestions, or generated code.

You can use it to:

Review a file and get feedback on code quality
Generate tests based on existing code
Debug issues by pointing it at a file and asking what’s wrong
Explain unfamiliar code or confusing logic
Generate commit messages, refactor functions, and more
Write new app features (front-end, APIs, database interactions, and more)

It remembers context within a conversation, so follow-up questions build on what came before.

What the course covers

The course is structured as 8 progressive chapters. Each one builds on the last, and you work with the same project throughout: a book collection management app. Instead of jumping between isolated snippets, you keep improving one codebase as you go.

Here’s what using GitHub Copilot CLI looks like in practice. Say you want to review a Python file for potential issues. Start up Copilot CLI and ask what you’d like done:

$ copilot
> Review @samples/book-app-project/books.py for potential improvements. Focus on error handling and code quality.

Copilot reads the file, analyzes the code, and gives you specific feedback right in your terminal.

Here are the chapters covered in the course:

Quick Start — Installation and authentication
First Steps — Learn the three interaction modes: interactive, plan, and one-shot (programmatic)
Context and Conversations — Using @ references to point Copilot at files and directories, plus session management with --continue and --resume
Development Workflows — Code review, refactoring, debugging, test generation, and Git integration
Custom Agents — Building specialized AI assistants with .agent.md files (for example, a Python reviewer that always checks for type hints)
Skills — Creating task-specific instructions that auto-trigger based on your prompt
MCP Servers — Connecting Copilot to external services like GitHub repos, file systems, and documentation APIs via the Model Context Protocol
Putting It All Together — Combining agents, skills, and MCP servers into complete development workflows
learning path image

Every command in the course can be copied and run directly. No AI or machine learning background is required.

Who this is for

The course is built for:

Developers using terminal workflows: If you’re already running builds, checking git status, and SSHing into servers from the command line, Copilot CLI fits right into that flow.
Teams looking to standardise AI-assisted practices: Custom agents and skills can be shared across a team through a project’s .github/agents and .github/skills directories.
Students and early-career developers: The course explains AI terminology as it comes up, and every chapter includes assignments with clear success criteria.

You don’t need prior experience with AI tools. If you can run commands in a terminal, you learn and apply the concepts in this course.

How the course teaches

Each chapter follows a consistent pattern: a real-world analogy to ground the concept, then the core technical material, then hands-on exercises. For instance, the three interaction modes are compared to ordering food at a restaurant. Plan mode is more like mapping your route to the restaurant before you start driving. Interactive mode is a back-and-forth conversation with a waiter. And one-shot mode (programmatic mode) is like going through the drive-through.

Later chapters use different comparisons: agents are like hiring specialists, skills work like attachments for a power drill, and MCP servers are compared to browser extensions. The goal is to provide you with a visual and mental model before the technical details land.

The course also focuses on a question that’s harder than it looks: when should I use which tool? Knowing the difference between reaching for an agent, a skill, or an MCP server takes practice, and the final chapter walks through that decision-making in a realistic workflow.

Get started

The course is free and open source. You can clone the repo, or open it in GitHub Codespaces for a fully configured environment. Jump right in, get Copilot CLI running, and see if it fits your workflow.

GitHub Copilot CLI for Beginners

For a quick reference, see the CLI command reference.

Subscribe to GitHub Insider for more developer tips and guides.

What’s in a Name? Fuzzy Matching for Real-World Data

Renee Noble — Fri, 17 Oct 2025 00:47:36 +0000

🎥 Watch the full PyCon AU 2025 talk here

When you work with human-entered data (registrations, surveys, customer forms, you name it!) you soon discover that people are very creative typists. Names, schools, companies, and addresses come in with abbreviations, nicknames, missing words, and typos galore.

That mess makes it hard to answer even simple questions like: “Do these two records refer to the same person?” or “How many participants came from this organisation?”

At PyCon AU 2025, I explored how different fuzzy matching techniques, from traditional algorithms to generative AI, can help make sense of that chaos.

The Fuzzy Matching Challenge

String comparison looks straightforward until you meet real-world data. “PLC Sydney” might really be “Presbyterian Ladies’ College Sydney.” “Certain Collage” is obviously a typo for “Certain College” (hopefully). And nicknames like Liz, Lizzy, and Elizabeth might all belong to the same person.

That’s where fuzzy matching comes in, using a variety of techniques we can rank how similar different non-identical words are to try and find the most likely match. But the question is, what fuzzy matching algorithms are best suited for matching what types of data? And can generative AI play a part in this matching game?

Comparing Algorithmic Approaches

I put six Python libraries to the test:

TextDistance and Python-Levenshtein – classic edit-distance approaches.
FuzzyWuzzy and RapidFuzz – hybrids that combine multiple distance metrics.
Nicknames and PyNameMatcher – specialised tools for given-name variations.

To test them, I generated around 100 fake student names with nicknames, misspellings, and swapped orderings. Then I measured how accurately each library matched them to their correct counterparts.

RapidFuzz came out ahead, matching almost every record correctly, and doing it fast! The edit-distance methods struggled most with multicultural names where order or character sets varied, and the nickname libraries were strong but less consistent overall.

When Generative AI Shines

Algorithmic fuzzy matching is fast and accurate, but it only looks at characters, not meaning. That’s where I turned to Azure OpenAI Service for a different kind of help.

By feeding in real school-name data, I found that straight out of the box GPT-5 was exceptionally good at recognising and correcting school names, especially when they were abbreviated, misspelled, or included local school nicknames.

For example, it could confidently map:

“PLC Syd” → “Presbyterian Ladies’ College Sydney”
“Cerdon Collage” → “Cerdon College”
“St Cats” → “St Catherine’s School, Waverley”

That level of contextual correction is almost impossible to achieve with pure algorithmic matching unless you maintain a custom dictionary of every possible variation. And who has time for that!

The trade-off, of course, is performance. Generative models are slower and costlier to run at scale. But when used selectively, just for ambiguous or hard-to-match cases, they can dramatically improve accuracy. And of course this is something this specifically works well for names, like schools, that are well documented on the internet – something that doesn’t apply to the names of individual school students.

Can we have the best of both worlds?

hybrid AI + Algorithmic matching!

In practice, the best results came from a hybrid approach, using traditional fuzzy-matching algorithms for most cases, and bringing in Azure OpenAI only when the names got tricky. For example, RapidFuzz could quickly match “Lizzy Wong” to “Elizabeth Wong,” while the generative model was better at reasoning through ambiguous inputs like “Sally-Anne W.” or reversed multicultural name orders. By combining both, I could match almost every student record accurately, keeping the speed of algorithmic methods while adding the contextual understanding of generative AI.

Try It Yourself

🎥 You can watch my full PyCon AU 2025 talk here:
What’s in a Name: Fuzzy Matching Techniques for Proper Nouns

📁 If you’d like to explore this further you can check out my fuzzy matching repo.

Take a look at the libraries and tool I mentioned above, they’re easy to install and experiment with in Python. If you’re already using Azure OpenAI, it’s worth testing how a small retrieval-augmented setup might complement your existing matching logic.

Chat to us!

💬 To chat more about AI solutions you can join the AI Foundry Discord, where advocates like me are chatting about the latest tools all the time.

Join the Azure AI Foundry Discord here

Good luck on your fuzzy matching adventures!

I really love working with the AZD team! They are bringing out new features that are really inline with developer needs all the time, so take a look at this big feature milestone!

Renee Noble — Tue, 01 Jul 2025 04:21:53 +0000

azd CLI extension framework

Kristen Womack ・ Jun 30

#programming #cli #azure #ai

Build faster with this simple AZD template for FastAPI on Azure App Service

Renee Noble — Fri, 02 May 2025 07:54:39 +0000

Whether you’re building your first web app or your fiftieth, you want it to be simple to deploy so you can spend your time on building your new idea and not on configuration options to get your service running in the cloud. And when you’re just getting started you don’t need huge scale, you probably want to deploy it on a free plan!

I’ve made this Simple FastAPI AZD template for Azure App Service to help you get to the fun part, and to cut out all the extra infrastructure that you don’t necessarily want or need. This FastAPI template for Azure App Service gives you all the infrastructure as code to deploy a basic “Hello World” FastAPI web app that you can spin up using AZD (Azure Developer SDK) with just three commands.

How to do it

To get started, you just need to install AZD, a command-line tool you can use right there in VS Code. Then you’re ready to grab the template and deploy. Run these commands and follow the prompts as you go.

Grab our new simple FastAPI template for Azure App Service:
azd init --template Azure-Samples/azd-simple-fastapi-appservice
It will ask you to give your environment a name. This will be used to name different resources that are deployed on Azure.
Log in to your Azure account:
azd auth login
Now for the magic! Well, not magic… in one command we can package up your code, provision the Azure resources, and deploy your web app:
azd up
You’ll get to choose the location where your web app deploys and the subscription you want to put it on.

If you loved how easy that was, you can check out more about AZD, how you can use it, and find more AZD learning resources on the Azure Developer SDK home page.

Why choose FastAPI on Azure App Service

FastAPI vs Other Python Frameworks

FastAPI is a great choice if you need to build APIs quickly and efficiently. It’s designed to be fast, easy to use, and powerful. Here’s why you might choose FastAPI over other Python frameworks like Flask or Django:

Speed and Native Asynchronous Support
FastAPI is built for high performance as it is built on Starlette (a lightweight ASGI framework), ideal for high-concurrency apps with many simultaneous users or pushing live updates, WebSocket connections, or where background data collection and processing are frequent.

Leveraging Python’s async and await keywords allows FastAPI to serve up your web app much faster than frameworks like Flask when handling many requests at once.

Pydantic for Type Hints, Data Validation, and Clear Error Messages

FastAPI uses Pydantic to enforce type hints and automatically validate request data. If the input is invalid, FastAPI returns clear, structured error messages without extra code. This makes APIs more reliable, user-friendly, and easier to debug. The automated error detection based on the Pydantic models you have specified also cuts down on test writing time as well as generating interactive API documentation automatically.

Clean and Extendable Code with Dependency Injection

FastAPI uses dependency injection to promote clean, maintainable, and modular code. Dependency injection is a design pattern where components (like functions or classes) are provided with their dependencies (e.g., database connections, external services) rather than creating them inside the function itself. This results in code that is easier to test, extend, and maintain – particularly when you consider the benefits of inheriting dependencies and the reduction of duplication of code this provides.

Overall, if you’re looking for a framework that makes API development faster and smoother, FastAPI is a great choice!

Why Azure App Service?

There are a lot of deployment strategies out there, but when you’re just getting started you don’t need a lot of the complex features and configurations. To keep it as simple as possible, I’ve built this template to use Azure App Service – which can take you a long way on your web app journey as your idea and scale grows.

Here’s a couple of points as to why using Azure App Service is a good way to get started with a new project, whether it’s a project you’re using for learning, a prototype, or for your global role out.

Get started for free
As the template comes, it is set to a basic plan (you can see the pricing per month here), but if you want to get started for free, you can easily update the template before you run azd up to leverage the free plan or the discounted developer plan!

To change the plan go to the template file infra/resources.bicep and update line 58 where the SKU is set to “B1” (“Stock-Keeping Units” is how we refer to the different plans that offer different amounts of RAM and storage). Change this to “F1” to deploy up to 10 App Service apps for free on the free plan (or “D1” for the discounted developer rate if you have more than 10 to deploy concurrently).

Scale far and wide
When you’re just getting started, you’ll already get the benefit of Azure’s global reach by selecting from one of the many server locations close to you, helping reduce lag for users in your region. Then, as your web app “grows up”, you’ll have a lot of options for how to scale to reach a growing and spreading user base.

Once you have a couple of people trying to use your site at the same time it’s probably time to move on up to a Basic plan (if you have changed the template to use the “F1” or “D1” plans), to give you a bit more RAM to serve your users quickly. Just change your SKU back to “B1” or look at the different plan options if you think you might need something a bit beefier! Even just upgrading to the Basic plan will start to get you access to automatic scaling features to help you scale globally by increasing the number of VM instances that run your app.

Easy to manage and deploy
If you are getting started with cloud, Azure App Service is a great place to start (and continue!). App Service allows you to manage your cloud-hosted web apps with less of a learning curve than you might experience with a container-based option and has clean-cut ways to be able to interact with your logs.

And, we’ve already discussed how easy it is to get this project up and running on the cloud with AZD, but Azure App Service also has built-in GitHub integrations and works with CI/CD pipelines that you can configure in GitHub to customise your deployment flow as you continue to build out your solution.

Summary

To wrap things up, I hope using my Simple FastAPI + Azure App Service template sounds good to you! You can easily use it for free, so why not see how much simpler it can make deploying a Python-backed web app to the cloud?

I hope you enjoy building on it and have a great time with all the benefits of the speedy and modular FastAPI framework, along with the simplicity, scalability, and integration options that Azure App Service provides

Deploy web apps with help from GitHub Copilot for Azure!

Renee Noble — Mon, 11 Nov 2024 06:03:20 +0000

I know that when I started building web apps, actually deploying my app to the web was the part that seemed the most out of reach. Speaking to a lot of other developers about their early experiences of web dev, I hear that story again and again. I even have many friends who are accomplished software engineers who don’t want anyone to know that they have never deployed a personal project to the web.

Once you’ve deployed something once, you’ll realise that it’s not so hard to get something up and running on the web, but the world of dev ops is growing and there is aways more to learn about how to manage your deployment. Whether you’re just getting started or expanding your skill set, there’s always room for a bit of help!

Over the last few months, I’ve been excited to play with the GitHub Copilot for Azure extension in VS Code, which is now in public preview!

Putting this extension through its paces, I tried to relive my first experiences of working with web apps now with GitHub Copilot for Azure on my team. After this experience, here are my top five prompt topics that I think are really great for new web app developers that I wish I had 10 years ago when I got started!

1. Skip the search engines and get relevant info right from your IDE.  

For those who are new to deploying something a web search of “how do I deploy a web app” seems pretty likely! Maybe you’ve heard about a few different deployment options, but how to actually get started with them is going to need a bit of research.

But the wider internet is full of people with a huge range of set ups, deploying a wide range of projects with different requirements and complexities. It’s easy to get lost in a Stack Overflow thread thinking “is this relevant to me???”.

Asking GitHub Copilot for Azure “Can you help me put my website on the internet” told me about the simplest service to use, provided me a link to the Azure Developer CLI documentation, and gave me suggested questions for my next steps!

Reflecting on my first experiences, knowing that you are following the right path and knowing what are useful things to think about and ask were the things I was the most uncertain about, so this was a great first step.    

2. Discover services and templates you wouldn’t otherwise know about! 

A simple statement like “I want to make a web app with Python”, could help you discover a bunch of resources that already exist! This response told me about AZD (Azure Developer CLI) as well as a template that exists for a Python Django web app that deploys on Azure App Service.     

If you haven’t heard of AZD before, this could be a game changer! AZD help you deploy from the command line in only a few keystrokes, and it has a best buddy, Awesome AZD, where a bunch of AZD templates live! Awesome AZD is full of different templates for common combinations of tech, for example here Python, Django, and Azure App Service. When it comes to dev ops there is a lot to know, but there’s no reason that you need to reinvent the wheel, especially if you are getting started and building a basic app. Awesome AZD apps have the dev ops covered for you by including infrastructure as code files (like Bicep files), that will configure your resources for you when you deploy your app using AZD.   

Once you see the different template options available on Awesome AZD, you might have questions on what is the best service to deploy your web app with, which you can once again ask to GitHub Copilot for Azure to get well informed and concise answers, as well as suggestions for questions on other topics you might want to consider, like cost management.     

3. Get the step-by-step instruction you need and skip the copy and paste! 

I am really loving not leaving VS Code as I go through the process of deploying something using the command line. Not only does the GitHub Copilot for Azure give you all the steps you need to deploy a web app (based on the actual documentation), all without having to leave your IDE, it also means you can skip the copy-paste routine that is normally associated with using command line prompts for the first time (at least for me!).

It gives you the necessary steps in a quickly easy to read format, but it also gives you the “Insert in Terminal” button (and keyboard shortcut) to make it easier, faster, and just less fiddly!

What is really great is it also crafts its answers based on the knowledge of your code base. If you have a file open it will automatically include that context when it creates a response for you. For projects started from AZD templates it will be able to give you all the quick and easy steps for initialising your project with AD, logging into to Azure from the terminal, and then deploying your web app right there in the command line.

This has to be the best thing by far for beginner deployers. With a few clicks of “Insert into Terminal” you can get your template up and running on the web. Then you have all the tools you need to build on your template and to continue to deploy new versions.   

4. Interrogate your own Azure account in natural language to get IDs, app names, and more   

Sometimes you just want a bit of information about a resource you have deployed, like what region it is in. Or maybe you want a list of all the resources you have on a particular service, or subscription.

You could get all that info by trawling through the Azure portal manually or jumping into the Azure Resource Graph and crafting a query. But I’d personally rather just have the answer! 

It's super-fast to get questions like that answered now without leaving VS Code, with quick natural language questions.

Once you have the name of a resource it’s easy to ask even more questions about it. Like getting the region it’s deployed in, or the date the resource was created.

I think this is the biggest time saver of all the prompts. The questions are so simple, but finding what you need in the Azure portal might take you a while, especially if you are new to it!  

5. Get tips on how to use the Azure portal!  

Sometimes GitHub Copilot for Azure isn’t the right tool for the question you have. But you’re not all alone now!   If you are new to the Azure portal, you might not know where everything is (I know I still find new things all the time!). When GitHub Copilot for Azure can’t give you the answer directly inside VS Code, it will give you instructions on how to get to the location in the Azure portal that will help you get your task done, and allow you to engage with a more rich Azure experience in the portal for seeing visualisations, building more sophisticated queries in for Azure Resource Graph, and more.

The Azure portal is really powerful once you know how to use it, so having a guide to where you need to look and what options you need to select is a huge help in getting your configuration set up and interacting with the full breadth of Azure functionality.

Give it a try!

These are just a few of the things I have tried with the GitHub Copilot for Azure extension in VS Code, and are some of the greatest things I’ve seen for new web developers hoping to deploy their first few web apps (and also just for anyone who is deploying things on Azure!). I hope you give these and many more prompts a try! I’ve had a lot of fun seeing what GitHub Copilot for Azure extension in VS Code can do as well as learning myself the best way to ask questions to get some spot-on answers!

Create and deploy a web app with Python and Azure – A video tutorial!

Renee Noble — Wed, 12 Jun 2024 07:06:08 +0000

Have you ever wanted to create your own website or web service, but felt overwhelmed about how to get started with web development? Or have you already built a web app with Python, but wondered how you can deploy it online? If so, you might be interested in watching this video by and Pamela Fox and me, Renee Noble! We're two Python Cloud Advocates at Microsoft with a passion for web development and education!

We’ll show you how to create a web app with Python Flask (or it’s async-sibling Quart) and show you how you can deploy you can take your web app live by deploying it on Azure. This is the first episode in a live stream series (that you can also catch on demand!) by Pamela and friends covering different web dev frameworks and practices! (And you can catch it in Spanish too!)

In this video, you will learn how the web works and why you (likely) need a web server to serve up your web app. You will also discover how a backend web framework, like Flask, helps you develop your web server quickly and easily and how it lets you use templates to build dynamic sites - whether it’s your first site or a complex full-scale service.

Want to improve your web server throughput? Find out how you can port your app to Quart, the asynchronous version of Flask. And of course, you’ll see how you can deploy your web apps to Azure App Service in minutes and learn what other deployment options you might be interested in seeking out depending on your project.

The video is perfect for beginners who have some familiarity with Python, but no prior experience with web development or deployment. It is also suitable for intermediate or advanced developers who want to refresh their skills or learn new tricks. Take a look at the video to learn some concepts and follow along with our coding and deployment demos! You can grab the demo repo here and check out the slides too.

Learn to build AI apps with Azure Cosmos DB!

Renee Noble — Wed, 01 May 2024 06:51:16 +0000

Microsoft Developers AI Learning Hackathon

Calling all developers! Want to learn how to build AI apps? Want to compete for $10K in prizes? Look no further! Join us for the Microsoft Developers AI Learning Hackathon! Let's delve into what this hackathon has to offer:

What is the Microsoft Developers AI Learning Hackathon?

The Microsoft Developers AI Learning Hackathon is an exciting global online event created to educate developers of all skill levels and backgrounds. From April 15th to June 18th, this hackathon welcomes participants to learn fundamental AI skills, develop their own AI copilot using Azure Cosmos DB for MongoDB, and compete for prizes.

Sign Up Now

Why should I participate?

Dive into foundational database technologies, the backbone of innovations like OpenAI’s ChatGPT. Put Azure Cosmos DB for MongoDB to work in real-world AI situations and compete for prizes totalling up to $10,000! Plus, participants will snag an exclusive badge to show off their newly acquired AI skills. Don't let this opportunity slip by – seize the chance to learn, create, and kickstart your AI learning journey on Azure!

About Azure Cosmos DB

Azure Cosmos DB is a fully managed and serverless distributed database for modern app development, with SLA-backed speed and availability, automatic and instant scalability, and support for open-source PostgreSQL, MongoDB, and Apache Cassandra. Try Azure Cosmos DB for free here. To stay in the loop on Azure Cosmos DB updates, follow us on X, YouTube, and LinkedIn.

Data Science & DevTools: GitHub Copilot

Renee Noble — Wed, 20 Mar 2024 05:01:47 +0000

Welcome to our third post of Developer Tools Week as we continue our learning journey into Data Science! Today, let's talk about the GitHub Copilot extension and how we can use it for focused learning inline, or in chat mode.

What We'll Learn

What is GitHub Copilot?
What can GitHub Copilot do?
GitHub Copilot For Data Science
Assignment: Visualize Data With GitHub Copilot
Resources: Explore the 2024: Data Science Day Collection

Bookmark and revisit these for more information:

Resource	Description
Collection 1️⃣	Skill up on Data Science Tools & Techniques
Collection 2️⃣	Skill up on Responsible AI Principles & Tooling
Collection 3️⃣	Build Generative AI Apps End-to-End with Azure AI

You've created a consistent and reproducible environment with GitHub Codespaces. You've got that instrumented with Jupyter Notebooks for interactive coding and shareable insights. And you've setup a Visual Studio Code profile with Data Science extensions and settings for a more productive developer experience. You've even walked through the basic Visual Studio Code data science tutorial.

What can you do next to enhance your developer experience and improve your productivity?. How about a tool that helps you stay focused and on-task while providing AI-assisted code completion and content suggestion capabilities relevant to that task context? Let's talk about GitHub Copilot!

1 | What is GitHub Copilot?

GitHub Copilot is an AI coding assistant that can improve your productivity with proactive suggestions (via auto-completion) and reactive responses (via interactive chat). It is installed as a Visual Studio Code extension, bringing AI-assisted development capabilities to your editor including:

Code generation. It can author code, tests, comments, and documentation to suit your request.
Auto completion. It can predict what your code needs next, based on current context.
Code refactoring. It can help you simplify code or fix issues with context-aware suggestions.

GitHub Copilot uses large language models (LLM) that are trained on large datasets of publicly available code on GitHub, and optimized for code-generation tasks. You can use the capability in two ways:

Passive Auto-Completion. As you write code or content, the AI predicts valid suggestions in real-time inline, in your editor. Simply accept valid suggestions, and customize them further if needed. For instance, the image shows how the AI suggests the next import in your Jupyter Notebook code cell - simply tab to accept the suggestion or esc to ignore it.
Interactive User Chat. Open a chat window (sidebar) or dialog (inline) to start an interactive question-answer session. You can accept/discard responses (inline) or copy/paste them from window. For example - I can now ask for more details about the suggested import in a chat window. Note how it uses the file as a context reference.

Think of GitHub Copilot as an assistive technology rather than an automation tool in your workflow. Since the technology uses an LLM, it may have inaccurate or outdated information - so make sure you validate responses before you accept them. Using this technology requires an active subscription but there is a 30-day free trial to help you evaluate the capability for your own needs. The Data Science Profile Template for Visual Studio Code adds this extension to your profile by default if used.

2 | What can GitHub Copilot do?

As we saw earlier, the AI can provide proactive suggestions (auto-completion) or reactive responses (user chat) using your current context (file or workspace) to ensure that responses are relevant to current tasks. In addition to these capabilities, the GitHub Copilot extension comes with built-in slash commands that are optimized for common tasks. Simply open the inline chat dialog (editor) or the dedicated chat window (side) and type / to see the available commands as shown:

Chat Commands	Inline Commands

The table below provides a short summary of what the commands do. Note that commands that can impact the currently-open file (e.g., add or modify code) can be used in both inline (dialog) and chat (window) modes. Other commands that are more general work only in the chat (window) pane.

Command	Description	Usage
/doc	Add comments for code using right syntax	Inline and Chat
/explain	Get code explanations in natural language	Inline and Chat
/fix	Fix problems in the specified code	Inline and Chat
/tests	Create unit tests for the selected code	Inline and Chat
/newNotebook		Chat only

3 | GitHub Copilot For Data Science

So how can you use GitHub Copilot to enhance your Python Data Analysis and Visualization learning journey? Let's check out some simple examples using the code repo for this workshop.

3.1 Use `/doc` to add comments

In this exercise, open the 3-copilot/02-cricketNotebook.ipynb notebook in your Visual Studio Code editor and let's explore using the /doc command to add comments to the first code cell. Not only does this encourage good documentation practices, it also helps you gain insight into what the code does if you are not the author (e.g., was auto-generated or written by someone else)

Inline Example	Chat Example

Note how the inline version provides a response that is formatted for inclusion into the code cell (with Accept/Discard) options) while the chat version provides more of an explanation of that code that could be used in a relevant user guide or tutorial. Hint: Try using the /explain command in chat mode instead to see how it compares to the response above.

Another useful feature in chat mode is the follow-up question suggested (at the bottom, in blue). These suggested prompts are a great way to build our intuition by following suggested questions based on the previous query, but still relevant to the context of our current task. Contrast this with "googling" for answers or "searching Stack Overflow" where you need to context-switch (to use a new site) and may end up in rabbit holes that keep you distracted and away from your original task.

3.2 Use `/tests` to write a unit test for the selected code

Let's try this out to see what happens. Select the same code cell above, then try using the /tests command inline.
It gives you the option to "View In Chat" so let's take that route to see what tests are suggested. We see two basic tests (check for existence of valid and non-existent files) plus some suggestions (check for empty files or poorly-formatted ones).
You will get a prompt to "Create" tests which will try to create a new tests notebook, with some issues. Instead, try copying the test code over into a new Python cell and run it, to verify it works.

There are more complex tests to write - but this showcases the streamlined developer experience for common tasks in VS Code.

3.3 Use `/newNotebook` to create notebooks

You can create a new Jupyter notebook with pre-written code and documentation for a stated goal. Let's try this out by asking GitHub Copilot to get us started with a notebook for visualizing the cricket data in the file we looked at before. This will create it as an untitled notebook with the outline specified in that response.

Save that to a file like 01-newNotebook.ipynb and try running it with no modifications. Note how there are errors because of the filename mismatch. (Note: I deleted sections of the saved file for simplicity - so the outline is truncated).

We can stay in the flow by asking the AI to fix the issue itself.

Then run it to see the fix resolved, and output generated as required.

You can now try asking the AI to write new code or content sections for you to explore specific visualizations or seaborn syntax and capabilities. Check out the 01-seaborn-datawrangler-ipl.ipynb file as an example of what is possible.

4 | Exercise: Try it yourself!

In the above exercises, we created a notebook using a sample data file, and walked through steps to get us to a basic data analysis and visualization result. Try replicating this with a dataset of your own (e.g., try the TED Talks dataset found under the 1-data/kaggle/ folder).

Want to learn where you can find more open datasets to explore? Watch out for the next post in this series, for some useful resources.

Bookmark and revisit these for more information:

Resource	Description
Collection 1️⃣	Skill up on Data Science Tools & Techniques
Collection 2️⃣	Skill up on Responsible AI Principles & Tooling
Collection 3️⃣	Build Generative AI Apps End-to-End with Azure AI

Data Science & DevTools: Visual Studio Code

Renee Noble — Sun, 17 Mar 2024 04:24:25 +0000

Welcome to the second post of Developer Tools Week as we continue our learning journey into Data Science! Today, let's talk about how we can get more productive by using Visual Studio Code as our editor, and creating a Data Science Profile for consistency and collaboration across projects and users.

What We'll Learn

Why use Visual Studio Code?
What is a VS Code Profile?
How do I create a Data Science Profile?
What is Data Wrangler?
How can I use Data Wrangler for Data Analysis?
Assignment: Complete the Data Science in VS Code Tutorial
Resources: Explore the 2024: Data Science Day Collection

Bookmark and revisit these for more information:

Resource	Description
Collection 1️⃣	Skill up on Data Science Tools & Techniques
Collection 2️⃣	Skill up on Responsible AI Principles & Tooling
Collection 3️⃣	Build Generative AI Apps End-to-End with Azure AI

In the last post we talked about GitHub Codespaces and how it helps create a reproducible development environment with minimal setup effort on your part. Today, we'll look at why Visual Studio Code is the perfect IDE (editor) for your data science projects in this environment.

1. Why Visual Studio Code?

We already saw how the dev container approach involved a Visual Studio Code client (in browser or on local device) connecting to a pre-built Docker container (hosted in GitHub Codespaces or Docker Desktop) to give us a familiar and seamless developer experience. But there are three more reasons why it's ideal for Data Science projects:

Jupyter Notebooks are supported natively in VS Code, making it easy to run and debug code in notebooks in a familiar environment.
VS Code Profiles let you create a reusable profile (defining settings, extensions and customizations) that can be shared across projects and users.
Data Wrangler is a code-centric data viewing and cleaning tool with a rich UI to view, clean & analyze data, and automatically generate Pandas code to perform the same operations.

Let's explore these capabilities briefly in the next couple of sections, then revisit the Visual Studio Code tutorial for data science using the Jupyter-Codespaces environment we set up in our workshop repository in the previous post.

2. Data Science Profile

If you are a frequent user of Visual Studio Code (e.g., content creation, programming in other languages, working with GitHub Codespaces) then you likely have Profiles setup for distinct contexts, to make you productive. By default, a profile lets you specify the settings, extensions and other customizations you want to use for a given context in a manner that is reusable and shareable across users and projects.

You can create a profile from the Command Palette (as shown above) or by clicking the gear icon in your sidebar and selecting the Profiles (Default) menu option. Once created, you can easily switch between profiles with a single click, making it easier to keep distinct yet customized editing preferences and dependencies for each project or domain you work in. You can also export profiles to either a Gist (online) or a file (local device) that others can then import to replicate your settings.

Visual Studio Code comes with curated profile templates that are pre-configured for popular extensions and capabilities, that you can use as the basis for creating your own. For example, the Data Science profile template has built-in support for Dev Containers, Jupyter, Python, GitHub Copilot, Data Wrangler etc, - giving us the solid foundation required for use in our Jupyter-Codespaces environment.

3. Data Wrangler Extension

You may have observed that the Data Science Profile has a Data Wrangler Extension included by default. What is it and why should we care? Data Wrangler is a code-centric tool for data viewing, cleaning and analyzing - that works seamlessly with data files you open in Visual Studio Code.

More importantly, it can automatically generate Pandas code to perform the same operations you perform in the UI, with easy ways to copy the code into a Jupyter Notebook or clipboard, to simplify your data analysis workflow even further. As a bonus, the extension automatically creates action buttons within your Jupyter Notebooks in contexts where a Pandas DataFrame is returned.

Clicking this opens a new Data Wrangler view as shown, allowing you to visually and interactively run operations to clean, filter, sort and analyze your data - before exporting generated code back to the Jupyter notebook into a Python cell exactly where you need it. This is a great way to learn core Pandas operations for data cleaning, and build intuition around the right operations to use for your data. And, it allows you to document and share these steps with others in a reproducible manner.

4. Data Science Tutorial

Let's bring all these elements together and see how Visual Studio Code works in practice for enhanching our Data Science journey. First, take a minute to review the Data Science section of the Visual Studio Code documentation.

Then, review the Data Science in VS Code Tutorial to get a sense of what you will learn by completing these steps using the Jupyter-Codespaces environment we set up earlier. The tutorial covers four stages of a data science workflow that we can adapt to our needs:

Setup your environment - we'll use our Jupyter-Codespaces template
Prepare the data - we'll launch Data Wrangler from the notebook
Train & evaluate - using scikit-learn (we'll revisit later)
Use a neural network - using Keras and TensorFlow (we'll revisit later)

To make this easier, I've created a data-science-tutorial notebook under the 4-vscode/ folder in the workshop repository with the first two stages of the tutorial completed as shown. Observe how the df.head() output now shows a Data Wrangler button below that launches the Data Wrangler view when clicked.

Here is a screesnhot showing how we can switch the Data Wrangler into Editing view, to perform operations on the data (e.g., sort, filter, group). These operations are recorded as Cleaning Steps (see sidebar lower left), with the code for each step auto-generated in the Data Wrangler pane (bottom, right). and then Export the generated code back to the notebook. When the steps are complete, then Export to notebook (see menu option, top) to get the code automatically inserted into a Python code cell in the notebook.

Use the notebook as a sandbox to explore various operations interactively on the data file - and observe how the Pandas code generated matches the requirement.

5. Assignment: Try it out!

It's your turn. Fork the repo, launch it in GitHub Codespaces, then open the 4-vscode /1-data-science-tutorial.ipynb notebook. You should see something like this - but with Select Kernel at the top right.
- First, "Clear all outputs" to start fresh
- Then, "Select Kernel" and chose the default Python environment
- Then "Run All" to view the outputs from each cell.

By completing the tutorial, you will not only get a good understanding of the steps involved in each stage, but you will end up with a notebook template you can reuse with other datasets, to experiment further and build your intuition.

In our next post, we'll explore the use of GitHub Copilot to automate the generation of notebooks, get explanations for code - and suggestions to build our intuition organicially - using this tutorial as a basis.

Data Science & DevTools: GitHub Codespaces

Renee Noble — Fri, 15 Mar 2024 21:42:24 +0000

Welcome to Developer Tools Week in our #14DaysOfDataScience journey. Today, let's talk about how we can setup and use pre-built development environments for productivity and convenience in learning.

What We'll Learn

What are Dev Containers?
Why use GitHub Codespaces?
What are Jupyter Notebooks?
Using Codespaces-Jupyter Template
Assignment: Fork the repo. Explore notebooks under 2-jupyter/.
Resources: Explore the 2024: Data Science Day Collection

Bookmark and revisit these for more information:

Resource	Description
Collection 1️⃣	Skill up on Data Science Tools & Techniques
Collection 2️⃣	Skill up on Responsible AI Principles & Tooling
Collection 3️⃣	Build Generative AI Apps End-to-End with Azure AI

It's Developer Tools Week!!

Welcome to Developer Tools Week on #14DaysOfDataScience.

Before we dive into the detail of today's post, let's set the stage for what we'll cover this week, and why. The main goal is to jumpstart our learning journey into data analysis and visualizaton (even if we lack expertise in data science or Python) by using developer tools and AI to fill in the gaps in knowledge and intuition. And, we want to use a goal-oriented approach to learning where we don't boil the ocean (by trying learn everything) but instead focus on learning what we need, when we need it, to get things done.

To be successful, we need our development environment to be:

Frictionless - I should be able to setup and get productive quickly. No more "it works on my machine" comparisons. It just works for everyone.
Focused - I should be able to ask question and solve issues without leaving my development environment. No more "I'll Google it" distractions.
Friendly - I should be able to share my environment with others, and collaborate with them in real-time. No more "I'll send you a screenshot" explanations.

In my talk at Python Data Science Day, I outlined a roadmap for this journey, with an exercise for each step, as shown below. Today, we'll start that journey by exploring steps 01 and 02 in the roadmap.

What are Dev Containers?

A dev container is a Docker container that can be configured from a devcontainer.json file, which in turn can be checked into your repository for version controlled usage, alongside your code. This allows you to define a consistent development environment that just works out of the box, and works the same way for everyone who launches it from your codebase.

Why use GitHub Codespaces?

The figure below give an overview of GitHub Codespaces, a development environment that hosts the devcontainer in the cloud, allowing you to connect to it from a Visual Studio Code editor in your browser, or on your desktop. Simple open a repository in GitHub, click the Code button, navigate to the Codespaces tab, and launch a new instance - to get a pre-built dev environment with no added effort.

You can use the same dev container configuration on your local device with Docker Desktop. But GitHub Codespaces has three added benefits:

Cloud-hosted - This means I can connect to the environment from anywhere, including mobile or tablet devices, with nothing more than a modern browser.
Codespaces secrets - Store environment variables (e.g., API keys) as Codespaces secrets associated with repositories to limit risk of exposure.
Collaboration - We can collaborate with others knowing that our setup is identical (including host hardware) - and can easily scale up our resource needs (CPU, storage) for the task without local hardware constraints.

What are Jupyter Notebooks?

Having a dev container makes our setup frictionless, but how can we make the learning journey friendly for collaboration with others? This is where Jupyter Notebooks can help. They provide an interactive environment that combines code (Python cell) with documentation (markdown cells) - and is a popular tool for data scientists to capture insights and provide step-by-step guidance for replicating their work. GitHub Codespaces uses Visual Studio Code as the default editor, giving us excellent built-in support for Jupyter Notebooks to make usage more frictionless.

Using Codespaces-Jupyter Template

Excellent - we've established that using a GitHub Codespaces (dev container) environment with a Visual Studio Code (editor) and Jupyter Notebooks (interactive code and docs) is the way to go. So .. where should we start?.

Turns out GitHub has a great codespaces-jupyter template that comes with out-of-the-box support for a data-science ready dev container configuration and three sample notebooks to jumpstart your learning.
I use this template in the workshop repo I setup for this series - under the data-science-day-2024 branch. Let's explore that next. To get started:

Fork the workshop repo to your GitHub account. Make sure you have the main branch only unchecked so you get all the branches.
Switch to the data-science-day-2024 branch then launch Codespaces as shown below, directly in the browser.
Alternatively, clone the repo to your local device, make sure you have Docker Desktop running, then follow these instructions to open it in a local container.
Either way, once the container is ready, you should see a view like this showing a Visual Studio Code editor with that repo source already loaded.

You are now ready to start exploring the notebooks under 2-jupyter/ and complete the associated exercises. To run a notebook the first time, open it in the editor - then Select Kernel, pick the Python Environments option and select the default choice. Here's what that looks like for the

Next, run the notebook (using Run All) to execute the code as shown. Note the three kinds of content visible in this notebook - markdown cells (for documentation), code cells (for Python code) and output cells (for results).

The matplotlib notebook teaches you to use that library for basic 2D plotting, while the population notebook introduces you to the pandas library for data manipulation, using tabular data loaded from a CSV file.

The image-classifier notebook shows you how to do machine learning in Codespaces by training and testing a simple image classifier.

Assignment:

We covered a lot of ground today. Now it's your turn to go out and try exploring GitHub Codespaces with Jupyter Notebooks for data analysis.

The repository should now have an fourth notebook (exercise) that you can use as a sandbox for experiments. Look at the example in there - then create your own code and markdown cells to try other ideas with different data.

Want to browse more articles in this series? Follow this org:

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.

And bookmark and revisit these for more information:

Resource	Description
Collection 1️⃣	Skill up on Data Science Tools & Techniques
Collection 2️⃣	Skill up on Responsible AI Principles & Tooling
Collection 3️⃣	Build Generative AI Apps End-to-End with Azure AI

The Data Science Developer Experience

Renee Noble — Thu, 14 Mar 2024 06:17:18 +0000

Welcome to week Day 07 of Foundations of Data Science Week. Today, we will explore tools used by data scientists and learn about what to expect at Data Science day.

Data science isn't just about having sharp analytical skills; the tools you use can really change how you tackle problems, accelerate the generation of insights, and make it easier to share what you've discovered.

Tools for Coding

Visual Studio Code (VS Code) is a versatile code editor that supports a multitude of programming languages, including those commonly used in data science such as Python and R. To enhance its capabilities for data science, there are several extensions you can install:

Python Extension: Offers comprehensive coding support for Python, including IntelliSense, linting, debugging, and code navigation.

Jupyter Extension: Enables you to directly create, edit, and run Jupyter notebooks within VS Code. Jupyter Notebooks are an interactive computing platform where you can combine code execution, text, mathematics, plots, and other visual media. This tool is perfect for tasks like exploratory data analysis (EDA), data cleaning, statistical modeling, and visualization.

Tools for Analysis

Pandas and NumPy: Pandas and NumPy are foundational Python libraries for data science. Pandas provide high-level data structures and functions designed for practical data analysis and manipulation, while NumPy offers comprehensive mathematical functions, random number generators, linear algebra routines, Fourier transforms, and more.

Matplotlib and Seaborn: Visualizing data is crucial for understanding complex datasets. Matplotlib and Seaborn are two Python libraries that offer a wide range of tools for creating static, animated, and interactive visualizations.

Scikit-learn for Machine Learning: When it comes to building predictive models, Scikit-learn is a Python library for building predictive models. It features a wide array of supervised and unsupervised learning algorithms, tools for model fitting, data preprocessing, model selection, and evaluation, designed for ease of use and flexibility.

Try it out yourself: Your first Data Science project in Visual Studio Code

In the following tutorial, you'll dive hands-on into the tools we've discussed in this series, experiencing firsthand some of the key data science tasks we've explored. This interactive session will not only solidify your understanding of these concepts but also prepare you for our next series of posts. There, we'll delve deeper into how to harness these tools' full potential and more, advancing your data science journey.

Data Science in VS Code tutorial

Don't forget that you can continue to build on your skills in the Data Science Cloud Skills Challenge!

Welcome to Data Science Day! 🎉

Python Data Science Day is a fantastic opportunity for Python developers, entrepreneurs, data scientists, students, and researchers to come together and explore modern solutions for data pipelines and complex queries.

The Python Data Science Day will feature a variety of sessions and lightning talks from experts in the field. Whether you’re interested in high-level programming topics or diving deep into specific features, there’s something for everyone. You'll be introduced to a variety of products and services, like the Data Science workload in Microsoft Fabric and Semantic Kernel SDK. You'll also learn more about data science techniques like data preparation, data analysis, and practical applications of these techniques.

We hope you can join us and interact with data science community in the chat. Missed a session? You'll be able to catch the recordings of anything you missed.

What's Next?

Now that you've learned basic fundamentals, you'll continue your data science journey in the next series of posts, focused on levelling up your skills with hands on tutorials.

More Data Science at Microsoft

Check out the Data Science Cloud Skills Challenge if you want to go through some self-paced learning! This challenge is active until April 15th, 2024.
Join us on Discord at https://aka.ms/python-discord
Data Scientist Certifications
Data Scientist Training Path

The Data Science Lifecycle

Renee Noble — Wed, 13 Mar 2024 06:07:01 +0000

Welcome to week Day 06 of Foundations of Data Science Week. Today, we will walk through the data science lifecycle: an essential roadmap for transforming raw data into meaningful insights.


Introduction to the Data Science Lifecycle - Sketchnote by @nitya

Data science isn’t just about crunching numbers; it’s a journey, from problem framing to actionable insights. At its core it's a process, and can be broken down into 5 stages.

Capturing: What's the problem?

Data scientists must frame the problem they aim to solve clarity on the problem statement is crucial.
This stage involves defining the problem as a question, understanding its context, and aligning it with organizational goals.

Once the problem has been accurately captured, then next is the process of data collection. Identifying the problem at hand enables data scientists to capture high-quality data, which is the backbone of any successful data science project.

Processing: Where do we go from here?

The processing stage of the lifecycle is where the magic happens! Here, data is transformed into actionable insights. Most of this step is centered around discovering patterns in the data as well as applying machine learning models. However, there's additional techniques that take place in this step. Some of the tasks performed in this step are:

Data Cleaning and Transformation: Alter, or mold the data to make it uniform without errors or inaccuracies and more suitable for analysis. For instance, converting decimal numbers into currency.
Dimensionality Reduction: Simplifying the model by removing excessive data that can create uncessacary model complexity.
Sampling: Capturing a subset of data to make computations faster and manageable.
Model Selection and Tuning: There's a vast number of options for selecting the right model, which are evaluated using metrics like accuracy, precision, and recall.
Model Training and Evaluation: Training models on prepared data and evaluating their performance to ensure accuracy and reliability.

Analysis: What does the data tell us?

The analysis stage is where data scientists dive deep into the processed data, and apply data analysis techniques to uncover the hidden patterns, trends, and correlations.

Insight Generation: Extracting and articulating insights from the model outcomes, which involves understanding the why behind the predictions or classifications made by the models.
Data Visualization: Creating visual representations of the analysis results to communicate findings clearly and effectively.
Exploratory Data Analysis (EDA): Technique used to understand and summarize the main characteristics of a dataset, often visually.

Communication: How do we share the insights with everyone?

The goal of the communication stage is to bridge the gap between data analysis and actionable insights, making complex findings accessible and understandable to stakeholders not directly involved in the data work. It entails:

Reporting: Crafting comprehensive reports that summarize findings in an accessible manner.
Presentations: Conveying insights through presentations, emphasizing key points and actionable recommendations with compelling storytelling.

Maintenance: How do we ensure longevity?

The maintenance stage focuses on sustaining the project's value over time through:

Performance Monitoring: Keeping an eye on the model’s performance to ensure its predictions remain relevant.
Data Security: Keeping the data secure through limiting access to only those who need it, adhering to local laws and regulations.
Updating Models: Refining and retraining models to adapt to new data or changes in underlying patterns.
Feedback Loop: Utilizing stakeholder and user feedback to continuously improve the model’s accuracy and effectiveness.

What's Next?

Tomorrow is a brief introduction to the tools data scientists use, and details about Data Science Day!

Learn More

More Data Science at Microsoft

Check out the Data Science Cloud Skills Challenge if you want to go through some self-paced learning! This challenge is active until April 15th, 2024.
Join us on Discord at https://aka.ms/python-discord
Data Scientist Certifications
Data Scientist Training Path

DEV Community: Renee Noble

Get started with GitHub Copilot CLI: A free, hands-on course

What GitHub Copilot CLI can do

What the course covers

Who this is for

How the course teaches

Get started

What’s in a Name? Fuzzy Matching for Real-World Data

The Fuzzy Matching Challenge

Comparing Algorithmic Approaches

When Generative AI Shines

Can we have the best of both worlds?

Try It Yourself

Chat to us!

I really love working with the AZD team! They are bringing out new features that are really inline with developer needs all the time, so take a look at this big feature milestone!

azd CLI extension framework

Kristen Womack ・ Jun 30

Build faster with this simple AZD template for FastAPI on Azure App Service

How to do it

Why choose FastAPI on Azure App Service

FastAPI vs Other Python Frameworks

Why Azure App Service?

Summary

Deploy web apps with help from GitHub Copilot for Azure!

1. Skip the search engines and get relevant info right from your IDE.

2. Discover services and templates you wouldn’t otherwise know about!

3. Get the step-by-step instruction you need and skip the copy and paste!

4. Interrogate your own Azure account in natural language to get IDs, app names, and more

5. Get tips on how to use the Azure portal!

Give it a try!

Create and deploy a web app with Python and Azure – A video tutorial!

Learn to build AI apps with Azure Cosmos DB!

Microsoft Developers AI Learning Hackathon

Sign Up Now

Data Science & DevTools: GitHub Copilot

What We'll Learn

1 | What is GitHub Copilot?

2 | What can GitHub Copilot do?

3 | GitHub Copilot For Data Science

3.1 Use /doc to add comments

3.2 Use /tests to write a unit test for the selected code

3.3 Use /newNotebook to create notebooks

4 | Exercise: Try it yourself!

Data Science & DevTools: Visual Studio Code

What We'll Learn

1. Why Visual Studio Code?

2. Data Science Profile

3. Data Wrangler Extension

4. Data Science Tutorial

5. Assignment: Try it out!

Data Science & DevTools: GitHub Codespaces

What We'll Learn

It's Developer Tools Week!!

What are Dev Containers?

Why use GitHub Codespaces?

What are Jupyter Notebooks?

Using Codespaces-Jupyter Template

Assignment:

Microsoft Azure Follow

The Data Science Developer Experience

Tools for Coding

Tools for Analysis

Try it out yourself: Your first Data Science project in Visual Studio Code

Welcome to Data Science Day! 🎉

What's Next?

More Data Science at Microsoft

The Data Science Lifecycle

Capturing: What's the problem?

Processing: Where do we go from here?

Analysis: What does the data tell us?

Communication: How do we share the insights with everyone?

Maintenance: How do we ensure longevity?

What's Next?

Learn More

More Data Science at Microsoft

1. Skip the search engines and get relevant info right from your IDE.  

2. Discover services and templates you wouldn’t otherwise know about! 

3. Get the step-by-step instruction you need and skip the copy and paste! 

4. Interrogate your own Azure account in natural language to get IDs, app names, and more   

5. Get tips on how to use the Azure portal!  

3.1 Use `/doc` to add comments

3.2 Use `/tests` to write a unit test for the selected code

3.3 Use `/newNotebook` to create notebooks