This course gives you easy access to an innovative description design framework used and created by experts in description design who design descriptions for highly interactive learning resources. Interactive learning resources are common, fun, and effective tools that engage learners in the classroom and in remote learning environments. Many of these interactives rely on the visual display. This limits non-visual experiences, and makes many interactive learning resources inaccessible to learners with significant visual impairments or print- and graphics-related disabilities. Descriptions are verbalized text for supporting non-visual access. This course will show you how to create descriptions, the verbalized text, needed to make interactive learning resources (interactives) accessible to learners who are blind or have a visual impairment (learners with BVI). The course weaves together concepts from inclusive design, web accessibility, and general best practices for description design for non-visual access. The main focus of the course is learning about and using the Description Design Framework created by design researchers at PhET Interactive Simulations. Through a series of design tasks, each preempted with examples and demonstrations, the course walks you through how to design descriptions for an interactive of your choosing. While prior experience in web accessibility, interaction design, and description is useful, it is not required for this course. We share many examples from our work, and include tips and design patterns that we have created and actively use to describe our highly interactive science and math simulations. If you have an interest in creating descriptions for interactive learning resources, join us in this course. The Description Design Framework helps us take a methodical approach to the challenging task of designing descriptions for interactives, and we want to share what we know so others can design engaging descriptions that support non-visual access to interactive learning resources.

In this 1-hour long project-based course, you will create an end-to-end Regression model using PyCaret a low-code Python open-source Machine Learning library. The goal is to build a model that can accurately predict the strength of concrete based on several fatures. You will learn how to automate the major steps for building, evaluating, comparing and interpreting Machine Learning Models for regression. Here are the main steps you will go through: frame the problem, get and prepare the data, discover and visualize the data, create the transformation pipeline, build, evaluate, interpret and deploy the model. This guided project is for seasoned Data Scientists who want to build a accelerate the efficiency in building POC and experiments by using a low-code library. It is also for Citizen data Scientists (professionals working with data) by using the low-code library PyCaret to add machine learning models to the analytics toolkit In order to be successful in this project, you should be familiar with Python and the basic concepts on Machine Learning Note: This course works best for learners who are based in the North America region. We’re currently working on providing the same experience in other regions.

This course is for professionals who have heard the buzz around machine learning and want to apply machine learning to data analysis and automation. Whether finance, medicine, engineering, business or other domains, this course will introduce you to problem definition and data preparation in a machine learning project. By the end of the course, you will be able to clearly define a machine learning problem using two approaches. You will learn to survey available data resources and identify potential ML applications. You will learn to take a business need and turn it into a machine learning application. You will prepare data for effective machine learning applications. This is the first course of the Applied Machine Learning Specialization brought to you by Coursera and the Alberta Machine Intelligence Institute.

If you have seen any of the news lately, it is not hard to imagine why software bugs cost the economy billions of dollars per year as well as costing lives. The ability to test your code (and other’s code) is probably one of the most important skills to know as a developer. Knowing how to track down and fix bugs is also critical. Testing can mean adding print statements to output data at certain points in a program to visually check it. Testing can also involve developing separate programs to test the functionality of the code itself. In this course, you will create a Python application that implements a new sorting algorithm. You will also create a test to sort the algorithm, and use debugging to find bugs in the code. Note: This course works best for learners who are based in the North America region. We’re currently working on providing the same experience in other regions.

A principle of DevOps is to replace manual processes with automation to improve efficiency, reduce human error, and accelerate software delivery. This requires automation that continuously integrates code changes and continuously delivers those changes to a production environment. This course introduces you to Continuous Integration and Continuous Delivery (CI/CD), an automated approach to software development. You’ll discover the benefits of CI/CD for creating a DevOps pipeline and explore popular CI/CD tools. You’ll examine the key features of CI, explore social coding, and the Git Feature Branch Workflow. You will also learn about standard CI tools and gain a deep understanding of GitHub Actions workflows and their components. This course provides an overview of CD and its goals, benefits, and best practices. You will learn the requirements of a CI/CD pipeline and discover standard CD tools. You will explore Tekton and discover how its components work together to create a CD pipeline. You will learn how to build a pipeline, pass parameters to a pipeline, build triggers to start pipeline runs, implement reusable tasks, and create custom tasks. You will discover how to complete your CD pipeline by building a container image and deploying your application to an OpenShift Kubernetes cluster. Throughout the course, you can hone your skills and challenge yourself through several hands-on labs.

Programming of any kind, including in game-development, can get complicated as the size and scope of a project increase. Investigating bugs and expanding the code with new functionality can be almost impossible if the code-structure is not well-thought-out. In this one-hour, project-based course, we will cover the fourth principle of "SOLID" programming: Interface Segregation Principle ("ISP") states that classes should not be required to implement methods or properties it doesn't use. This means a monolithic interface is usually inefficient and should be broken into its functional parts. In the project, we will create some "typical" code that is fairly common in game-development, and then restructure it to become compliant with ISP. This project is part four of a five-part series on SOLID Programming principles, which are: - Single Responsibility - Open-Closed - Liskov's Substitution - Interface Segregation (this guided project) - Dependency Inversion Each of these guided projects stands on its own, but for a full understanding of good coding practices, completing all five guided projects (in order) is recommended.

This course covers the fundamentals of imaging – the creation of an image that is ready for consumption or processing by a human or a machine. Imaging has a long history, spanning several centuries. But the advances made in the last three decades have revolutionized the camera and dramatically improved the robustness and accuracy of computer vision systems. We describe the fundamentals of imaging, as well as recent innovations in imaging that have had a profound impact on computer vision. This course starts with examining how an image is formed using a lens camera. We explore the optical characteristics of a camera such as its magnification, F-number, depth of field and field of view. Next, we describe how solid-state image sensors (CCD and CMOS) record images, and the key properties of an image sensor such as its resolution, noise characteristics and dynamic range. We describe how image sensors can be used to sense color as well as capture images with high dynamic range. In certain structured environments, an image can be thresholded to produce a binary image from which various geometric properties of objects can be computed and used for recognizing and locating objects. Finally, we present the fundamentals of image processing – the development of computational tools to process a captured image to make it cleaner (denoising, deblurring, etc.) and easier for computer vision systems to analyze (linear and non-linear image filtering methods).

This is a self-paced lab that takes place in the Google Cloud console. In this lab, you will get hands-on practice configuring and deploying an App Engine instance with the APIs Explorer tool.

Have you ever heard that computers "think"? Believe it or not, computers really do not think. Instead, they do exactly what we tell them to do. Programming is, "telling the computer what to do and how to do it." Before you can think about programming a computer, you need to work out exactly what it is you want to tell the computer to do. Thinking through problems this way is Computational Thinking. Computational Thinking allows us to take complex problems, understand what the problem is, and develop solutions. We can present these solutions in a way that both computers and people can understand. The course includes an introduction to computational thinking and a broad definition of each concept, a series of real-world cases that illustrate how computational thinking can be used to solve complex problems, and a student project that asks you to apply what they are learning about Computational Thinking in a real-world situation. This project will be completed in stages (and milestones) and will also include a final disaster response plan you'll share with other learners like you. This course is designed for anyone who is just beginning programming, is thinking about programming or simply wants to understand a new way of thinking about problems critically. No prior programming is needed. The examples in this course may feel particularly relevant to a High School audience and were designed to be understandable by anyone. You will learn: -To define Computational Thinking components including abstraction, problem identification, decomposition, pattern recognition, algorithms, and evaluating solutions -To recognize Computational Thinking concepts in practice through a series of real-world case examples -To develop solutions through the application of Computational Thinking concepts to real world problems

By the end of this project you will create an affinity diagram using Creately.com. Learning to collect and organize ideas and information increases productivity and fosters positive teamwork. Learners will engage in the Affinity process to develop an understanding of how to spark, gather, consolidate, sort and present ideas and information.