Inhalt: If you're serious about digital illustration, there's a good chance you use a Wacom tablet. But are you getting the most out of your tools? In this course, Adobe Certified Instructor Kevin Stohlmeyer shows how to optimize your Wacom tablet for use with Photoshop. He reviews each component of the tablet and Grip Pen and shows how to adjust preferences and customize your tablet to work best with Photoshop. Plus, he helps you experiment with Photoshop's default brushes, natural tips brushes, erodible brushes, and Mixer Brush. Umfang: 00:47:39.00
Inhalt: It's easier to learn a new skill when you're designing something fun! In this course, you'll learn the ins and outs of creating and using custom brushes in Illustrator, while designing a full-size, Sherlock Holmes-inspired poster. Author Kevin Stohlmeyer walks through scanning the source materials, transforming them into Illustrator brushes, and then using them to create the final print-ready poster design. Umfang: 00:36:12.00
Inhalt: If you know even a little bit about programming languages, you know there are a plethora of options to choose from. If your priority is a language focused on reliability, speed, memory, safety, and parallelism, then Rust may be the one for you. In this course, instructor Barron Stone covers the key components of Rust, starting with basic programming concepts including variables, data types, functions, and control loops. He then moves on to some of the core concepts that are unique to Rust, including ownership, borrowing references, and crates. While Rust is great for low-level systems programming, it's also being used for web apps, network services, and embedded programs. As Barron shows, the features of Rust, along with great tools, documentation, and a welcoming community, have made Rust a language that developers love. Umfang: 06:41:42
Inhalt: Parallel programming unlocks a program's ability to execute multiple instructions simultaneously, increases the overall processing throughput, and is key to writing faster and more efficient applications. Curious about how parallel programming works in the real world? In this course, join instructors Barron and Olivia Stone as they introduce the basics of parallel programming in Python, providing the foundational knowledge you need to write more efficient, performant code. Barron and Olivia explain concepts like threading and mutual exclusion in a fun and informative way, relating them to everyday activities you perform in the kitchen. To cement the ideas, they demo them in action using Python. Each lesson is short and practical, driving home the theory with hands-on techniques. Umfang: 02:11:59.00
Inhalt: Put an end to writing command-line interfaces for your programs. Use Tkinter, the Python package for creating themed interface elements with the Tk GUI toolkit. Join Barron Stone in this course as he walks through the most popular Tk widgets and shows you how to customize their appearance and behavior to fit your application. Learn how to manage the placement of those widgets on the GUI and make them react to user behavior with event-driven code. The final chapter takes you through the entire start-to-finish process of building the user interface for an application, so you can see how all of these techniques work in a real-world development scenario. Umfang: 04:55:26.00
Inhalt: There are thousands of different types of sensors out there, acquiring and measuring data from the real world. But how do you get that data into the computer for processing? LabView is a leading system-engineering platform for interfacing with data-acquisition hardware. In this course, Barron Stone demonstrates how to program LabVIEW to control National Instruments data acquisition (DAQ) hardware and acquire and generate analog and digital signals. Barron provides guidance on choosing devices, setting up LabVIEW, connecting and simulating devices, and acquiring both analog and digital input and output. He also explains how to configure LabVIEW triggers, log data, read files, and connect third-party hardware with the wide variety of instrument drivers available for LabVIEW. Umfang: 03:03:26.00
Inhalt: As is the case with many technical projects, it's possible to assemble an electronic circuit without really understanding the different parts involved-you can just connect components together to match an electronic schematic. That said, in order to debug an existing circuit-or design your own-you have to actually understand how the individual electrical components work and how to use them together. In this course, join electrical engineer Barron Stone as he shares the knowledge and tools you need to learn exactly that. Barron demonstrates how to build basic circuits using resistors, capacitors, and inductors. He dives into how each component works and shows the common circuits that use them. He explains the difference between alternating current and direct current and how to use an oscilloscope to view electrical signals. Then, he demonstrates building passive filter circuits to remove unwanted frequency components from those signals. Umfang: 04:02:43.00
Inhalt: With parallel computing, you can leverage multiple compute resources to tackle larger problems in a shorter amount of time. In this course, the second in the Parallel and Concurrent Programming with Java series, take a deeper dive into the key mechanisms for writing concurrent and parallel programs. Instructors Olivia and Barron Stone make these (often abstract) concepts down-to-earth, demonstrating key ideas using common kitchen activities. Learn all about synchronization, thread pools, asynchronous tasks, evaluating parallel performance, designing parallel programs, and more. Upon wrapping up this course, you'll have a solid understanding of how to parallelize a sequential program. Umfang: 02:14:13.00
Inhalt: If you're charged with collecting and processing data from a variety of devices and systems-and, in turn, need to build software that interfaces with test and measurement equipment-traditional, text-based programming approaches may not be ideal. LabVIEW-a popular systems engineering platform-offers a unique approach. Using block diagrams, you can create virtual instruments that contain the logic you'll need to work with for your real devices, as well as build control panels that will help you monitor and manage them. In this course, instructor Barron Stone helps you get up and running with LabVIEW, showing how to write programs using its graphical programming approach. Along the way, he provides challenges and solutions that help you test your skills. Umfang: 02:58:57.00
Inhalt: Successful programmers know more than just how to code. They also know how to think about solving problems. Code Clinic is a series of courses where our instructors solve the same problems using different programming languages. Here, Barron Stone works with Python. Barron introduces challenges and provides an overview of his solutions in Python. Challenges include topics such as statistical analysis and accessing peripheral devices. Visit other courses in the series to see how to solve the same challenges in languages like C++, C#, JavaScript, PHP, Python, Ruby, Go, and Swift. Umfang: 01:51:09.00
Inhalt: Working with electronics can be a ton of fun, but it can also be a bit confusing-especially when you're first learning. In this course, electrical engineer Barron Stone uses easy-to-understand analogies to break down the fundamental concepts of voltage, current, resistance, and power. After you review the science behind electricity, Barron applies those concepts to build basic circuits. He explains the differences between the ideal, theoretical power sources that we often consider when designing circuits and the physical limitations of the real-world power sources that we actually use to build them. He also shows you how to use the go-to tool for debugging electronics-the digital multimeter-so you can measure the actual voltage and current in your circuits. Umfang: 01:17:07.00
Inhalt: Parallel programming unlocks a program's ability to execute multiple instructions simultaneously. It increases the overall processing throughput and is key to writing faster and more efficient applications. This training course introduces the basics of parallel programming in Java, providing the foundational knowledge you need to write more efficient, performant code. Instructors Barron and Olivia Stone explain concepts like threading and mutual exclusion in a fun and informative way, relating them to everyday activities you perform in the kitchen. To cement the ideas, they demo them in action using Java. Each lesson is short and practical, driving home the theory with hands-on techniques. Umfang: 02:15:20.00
Inhalt: All good software starts with a great design. Object-oriented design helps developers plan applications before they write a single line of code, and break down ideas into reusable and maintainable components. This course focuses on the foundational concepts, teaching them in a fun, interactive way to help you quickly develop your skills. Tag team Olivia and Barron Stone introduce you to the concepts and terms-objects, classes, abstraction, inheritance, and more-that you need to get started. They then show how to take the requirements for an app, identify use cases, and map out classes using Universal Modeling Language (UML). The final design can then be translated into code using one of the many popular object-oriented programming languages, such as Java, C#, Ruby, or Python. Umfang: 02:40:37.00
Inhalt: Parallel programming unlocks a program's ability to execute multiple instructions simultaneously. It increases the overall processing throughput and is key to writing faster and more efficient applications. This training course introduces the basics of concurrent and parallel programming in C++, providing the foundational knowledge you need to write more efficient, performant code. Instructors Barron and Olivia Stone explain concepts like threading and mutual exclusion in a fun and informative way, relating them to everyday activities you perform in the kitchen. To cement the ideas, they demo them in action using C++. Each lesson is short and practical, driving home the theory with hands-on techniques. Umfang: 01:59:04.00
Inhalt: Parallel programming is key to writing faster and more efficient applications. This course, the second in a series from instructors Barron and Olivia Stone, introduces more advanced techniques for parallel and concurrent programming in Python. Barron and Olivia explain concepts like condition variables, semaphores, barriers, and thread pools in a fun and informative way, relating them to everyday activities you perform in the kitchen. They also explain how to evaluate your code's performance and design more efficient parallel programs from the start with techniques like partitioning. To cement the ideas, they demo them in action using Python-closing the course with a variety of coding challenges. Each lesson is short and practical, driving home the theory with hands-on techniques. Umfang: 02:19:32.00
Inhalt: Bolster your understanding of how to build electronic circuits by learning to work with semiconductor components. In this course, join electrical engineer Barron Stone as he walks through how to build circuits using three common types of semiconductor components: diodes, transistors, and operational amplifiers. Barron kicks off the course by explaining what diodes are, and how to use diodes to control the direction that current flows through a circuit. He shows you how to use diodes to protect your circuits from large amplitude signals, reverse current, and flyback voltage. He then moves on to working with transistors, demonstrating how they can be used to control the amount of current flowing through a circuit, and examining common types of transistors such as BJTs and MOSFETs. Barron wraps up the course by covering one of the most useful electronic components-operational amplifiers. He shows you how to use op-amps to supply dual voltages, compare two signals, amplify signals, filter signals, and more. Umfang: 04:08:40.00
Inhalt: Understanding core programming concepts and why they are used is just as important as knowing how to write code. New programmers need to learn to bridge the gap: to connect the theory to practice. This series of training videos explains basic programming concepts by relating them to real-life objects, actions, and scenarios. Each video will focus on a different analogy, mixing live action with segments that demonstrate the concepts in code. For example, Barron Stone connects functions to recipes, lists to parking spaces, and loops to that perpetual chore: dishwashing. He illustrates most of the examples using Python, but you can follow along in any language you choose. Start watching and learn about... Reusing functions Local vs. global variables Creating and naming custom objects Class inheritance Modules and packages Multidimensional lists and tuples Queues and stacks Creating and combining sets Storing data in dictionaries If/else and switch statements For vs. while loops Error handling Polling and event-driven programming Umfang: 03:08:39.00
Inhalt: Write more efficient, performant code by mastering the fundamentals of parallel programming. In this course, instructors Barron and Olivia Stone pick up where they left off in the first installment of the Parallel and Concurrent Programming with C++ series, explaining what you need to know to write programs that execute multiple instructions simultaneously. Barron and Olivia dig into some more advanced concepts like condition variables and semaphores in a fun and informative way, relating them to everyday activities you perform in the kitchen. To cement these ideas, they demo them in action using C++. Each lesson is short and practical, driving home the theory with hands-on techniques. Umfang: 02:13:10
Inhalt: Want to test your Python skills? These concise challenges let you stretch your brain and test your talents. Instructor Barron Stone shares over a dozen Python challenges, as well as his own solutions to each problem-the majority of which are less than two dozen lines of code. You can tackle each problem using the tools in the Python standard library, or opt for the library of your choice. And since each challenge is self-contained, you can complete the course in any order-and at your own pace. Tune in to get the hands-on practice you need to keep your skills sharp. Umfang: 00:48:50.00
Inhalt: DevOps engineer is one of the most in-demand tech jobs on the market. But since this role is still relatively new, aspiring DevOps engineers may have a somewhat murky understanding of what the position entails. In this course, Laura Stone clearly outlines what's expected of DevOps practitioners, as well as what it takes to become a DevOps engineer (and how to excel once you've landed the job). She begins by highlighting the basic qualifications and training needed to land a job as a DevOps practitioner. Next, she provides a technical roadmap for the skills needed to gain an entry-level role in DevOps; shares tips from a DevOps recruiter; and provides steps for measuring progress and achieving your goals throughout your DevOps career. Umfang: 00:32:12.00
Inhalt: Microservices-a technique where software is structured as a set of loosely coupled services-improve the composability and maintainability of code. They help engineering teams ship high-quality code faster. Once you are aware of their benefits, you may want to know how to operate microservices in an actual production environment. This course focuses on the tools, processes, and strategies you need to successfully adopt a microservices architecture in production. Instructor Laura Stone explains how to establish service readiness-from testing strategies to continuous integration and delivery, versioning, documentation, and more. Then explore different integration methods that will ensure the resilience of your architecture, as well as best practices for logging and monitoring and incident response. The course wraps with a look at a case study and some tips for overcoming the technical and cultural challenges in adopting microservices at an organization. Umfang: 02:12:10.00
Inhalt: Software teams are expected to both maintain the quality of existing applications and innovate on new features that excite users. For engineering and operations teams, tackling both of these efforts on a deadline can be challenging. In this course, learn how to leverage error budgets and service-level indicators (SLIs), service-level objectives (SLOs), and service-level agreements (SLAs) to set realistic performance expectations and measure system performance within your organization. Instructor Laura Stone shows how to create SLIs to measure the reliability of a system, as well as how to make those SLIs meaningful with SLOs. Laura also shows how to use error budgets to ensure that poor service performance has consequences. To wrap up, she goes over the main components of SLAs. Umfang: 00:41:47.00
Inhalt: Get better insights into your back-end performance-whether your applications run on site or in the cloud. StatsD, Graphite, and Grafana are three popular open-source tools used to aggregate and visualize metrics about systems and applications. This course shows how to use them in combination to stay on top of outages, diagnose issues related to database and server performance, and optimize your user experience. Instructor Laura Stone-a senior-level site reliability engineer-explains how to gather app-specific metrics with StatsD, store those metrics efficiently with Graphite, and monitor and beautifully visualize this information with Grafana. Follow along to learn how to install, configure, and use these tools to create informative, useful dashboards that provide insights into multiple applications and systems-deepening your understanding of the performance and business value of your organization''s architecture. Umfang: 01:49:00.00
Inhalt: Successful programmers know more than just how to code. They also know how to think about solving problems. Code Clinic is a series of courses in which our instructors solve the same problems using different programming languages. In each course, instructors provide tips and tricks for working in a particular language and help you grasp why you might want to learn one language over another. Here, Olivia Stone works with C++. Throughout the course, Olivia provides an overview of her solutions to different challenges in C++. Challenges include topics such as geolocation, face recognition, and accessing peripherals. Visit other courses in the series to see how to solve the same challenges in languages like JavaScript, PHP, Python, Ruby, Go, and Swift. Umfang: 01:39:15.00
Inhalt: Love LEGOs? The next generation is ready to play. LEGO Mindstorms is a robotics kit designed for all experimenters-not just kids. Its advanced programming capabilities and robust hardware-sensors, motors, and intelligent EV3 brick-make LEGO Mindstorms a fun and challenging microcomputer system for programmers and tinkerers of any age. In this course, Olivia Chiu helps you "open the box" and build your first functional robot with LEGO Mindstorms. Learn how to unpack the hardware, connect to the programming interface, run prebuilt programs, and control the motors and sensors. Chapter 6, "Adding Flow to a Program," covers advanced programming topics such as transferring data between blocks, using variables to store temporary data, programming conditional logic, and looping actions to run again and again. By the end of the course, you'll have the skills to bring your own robotic creations to life. Umfang: 02:37:36.00
Programm Findus Internet-OPAC findus.pl V20.235/8 auf Server windhund2.findus-internet-opac.de,
letztes Datenbankupdate: 07.05.2024, 18:13 Uhr. 634 Zugriffe im Mai 2024. Insgesamt 510.864 Zugriffe seit Januar 2009
Mobil - Impressum - Datenschutz - CO2-Neutral