Log in
Log inBook a demo
75760 results
Sort by
COURSE
iOS Networking with Swift
Udacity
In this course, you’ll learn how to incorporate networking into your apps, so they can access data from around the world. You’ll learn how to harness the power of APIs to display images and retrieve movie data. At the end of the course, you’ll build the “On the Map” app which allows you to share interesting links, projects, or other information with fellow Udacity students. Why Take This Course? Without networking, mobile apps can only perceive, process, and present the data that is local to the host device. This greatly restricts the scope of problems which apps can solve and limits their overall utility. By incorporating networking, apps truly become “mobile” -- they can interact with interesting data using popular web services, coordinate multi-user activities, and build experiences that bring users together. This course will cover concepts fundamental to communication over the network like HTTP, JSON, and authentication. These concepts are also highly transferrable to other platforms, languages, and applications. Additionally, it will mold your understanding of app design, especially when networking constraints are involved. Prerequisites and Requirements This course assumes prior iOS experience. Specifically, you’ve built several apps, know how to use core iOS libraries, and are familiar with MVC design principles. Introduction to iOS App Development with Swift and UIKit Fundamentals are good courses to take if you need to familiarize yourself with these concepts. The course also assumes basic familiarity with Git. Specifically, you will need to be able to clone Git repositories and checkout branches specific to each lesson. How to Use Git & GitHub is a great option if you need to brush up on these skills. You will need access to a Mac computer running OS X 10.10 or later. However, you do not need an iPad or iPhone to complete the activities. All exercises can be completed using the iOS simulator built into Xcode. What Will I Learn? On the Map By incorporating networking, apps truly become “mobile” -- interacting with interesting data using popular web services. In this project, you’ll build your first networked app that displays information posted by other Udacity students. You’ll create a map view with pins representing student locations, and by tapping a pin, the app will display a custom URL posted by a student. Syllabus Lesson 1: Networking and Web Services In this lesson, you’ll learn all about networks and how they work. You’ll also build your first app that utilizes a web service: “Sleeping in the Library.” This app uses the Flickr API to pull pictures of people sleeping in libraries. Lesson 2: Building “Flick Finder” In this lesson, you’ll learn how to parse JSON data and display it to a user. You’ll demonstrate these new skills by building the “Flick Finder” app, which displays Flickr images based on a phrase or location. Lesson 3: The MovieDB and Authentication In this lesson, you’ll learn the difference between user and anonymously accessed data. You’ll do so by building the “My Favorite Movies” app that utilizes the Movie Database API. Lesson 4: Improving Networking with MVC In this lesson, you’ll improve on your “My Favorite Movies” app to build the “Movie Manager” app. For this app, we’ll be sure to use good MVC design, and learn what this means from a networking perspective. Lesson 5: Preparing for “On the Map” In this lesson, you’ll start on your final project app, “On the Map.” You’ll also learn about network reliability, and how your app should behave if a network can’t be reached.
COURSE
Computer Networking
Udacity
This class is offered as CS6250 at Georgia Tech where it is a part of the Online Masters Degree (OMS). Taking this course here will not earn credit towards the OMS degree. This course covers advanced topics in Computer Networking such as Software-Defined Networking (SDN), Data Center Networking and Content Distribution. The course is divided into three parts: Part 1 is about the implementation, design principles and goals of a Computer Network and touches upon the various routing algorithms used in CN (such as link-state and distance vector). Part 2 talks about resource control and content distribution in Networking Applications. It covers Congestion Control and Traffic Shaping. Part 3 deals with the operations and management of computer networks encompassing SDN's (Software Defined Networks), Traffic Engineering and Network Security. Why Take This Course? Want to build on your Computer Networking knowledge or move into Network Engineering positions such as Systems Admin, Network Admin or Technical Operations (WebOps)? If so, this is the class for you. Computer Networking takes a hands-on approach to teaching very technical material, using Mininet (a network emulator) to show you how a computer network functions, what factors contribute to its efficiency and how to overcome inherent limitations. Prerequisites and Requirements The ideal preparation for this course would be the successful completion of an undergraduate level Computer Networking course. An understanding of the TCP/IP protocol and the its layer model is recommended. Basic knowledge of python (such as through Intro to Computer Science) is required. You should be comfortable with the implementation of basic search algorithms and a working knowledge of Linux and virtual machines is recommended. Syllabus Lesson 1: Introduction Computer Networking Overview What This Class is Not About Lesson 2: Architecture & Principles A Brief History of the Internet Architectural Design Principles Packet Switching File Transfer End to End Argument Violations Lesson 3: Switching Switching and Bridging Bootstrapping: Networking Two Hosts ARP: Address Resolution Protocol Interconnecting LANs with Hubs Switches: Traffic Isolation Spanning Tree Switches vs. Routers Buffer Sizing for a TCP Sender Lesson 4: Routing Internet Routing Intra-AS Topology Distance-Vector Routing Link State Routing Interdomain Routing IGP vs. iBGP BGP Route Selection Multiple Exit Discriminator (MEI) Interdomain Routing Business Models Lesson 5: Naming, Addressing & Forwarding IP Addressing Pre-1994: “Classful” Addressing IP Address Allocation Classless Interdomain Routing (CIDR) Multihoming Frustrates Aggregation Address Lookup Using Tries Memory Efficiency and Fast Lookup Alternatives to LPM with Tries NAT and IPv6 Network Address Translation (NAT) Lesson 5.1: Router Design Basics Router Design Basic Router Architecture Decision: Crossbar Switching Switching Algorithm: Maximal Matching Head of Line Blocking Scheduling and Fairness Max-Min Fairness Lesson 5.2: Domain Name System (DNS) Record Types Examples (using “dig”) Lookup IP Address Lesson 6: Congestion Control & Streaming Congestion Control AIMD (TCP Congestion Control) Data Centers & TCP “Incast” Barrier Synchronization & Idle Time Multimedia & Streaming Digitizing Audio & Video Streaming Video Skype Lesson 7: Rate Limiting and Traffic Shaping Traffic Classification & Shaping Source Classification Leaky Bucket Traffic Shaping (r, t) Traffic Shaping Shaping Bursty Traffic Patterns Power Boost Effects on Latency Buffer Bloat Packet Monitoring Lesson 8: Content Distribution The Web and Caching HTTP Requests Persistent Connections Content Distribution Networks (CDNs) Server Selection Content Routing Bit Torrent Solution to Freeriding: “Choking” Distributed Hash Tables Consistent Hashing Lesson 9: Software Defined Networking Network Management Overview Software Defined Networking (SDN) Control and Data Planes Different SDN Controllers NOX: Overview Ryu, Floodlight, Nox and Pox Customizing Control Lesson 10: Traffic Engineering Traffic Engineering Overview Interdomain Traffic Engineering Measuring, Modeling and Controlling Traffic Link Utilization Function BGP in Interdomain Traffic Engineering Multipath Routing Data Center Networking Valiant Load Balance Jellyfish Data Center Topology Lesson 11: Network Security Internet is Insecure Resource Exhaustion Routing Security Origin and Path Authentication DNS Security DNS Cache Poisoning Lesson 11.1: Internet Worms Viruses and Internet Worms Internet Worm Lifecyle First Worm: “Morris” Worm Worm Outbreaks in Detail Modeling Fast-Spreading Worms Lesson 11.2: Spam Spam IP Blacklisting Lesson 11.3: Denial of Service (DoS) Attacks TCP 3-Way Handshake Inferring Denial of Service Activity using Backscatter Automated DoS Attack Mitigation MTPCP
COURSE
Machine Learning for Trading
Udacity
This course introduces students to the real world challenges of implementing machine learning based trading strategies including the algorithmic steps from information gathering to market orders. The focus is on how to apply probabilistic machine learning approaches to trading decisions. We consider statistical approaches like linear regression, KNN and regression trees and how to apply them to actual stock trading situations. Why Take This Course? By the end of this course, you should be able to: Understand data structures used for algorithmic trading. Know how to construct software to access live equity data, assess it, and make trading decisions. Understand 3 popular machine learning algorithms and how to apply them to trading problems. Understand how to assess a machine learning algorithm's performance for time series data (stock price data). Know how and why data mining (machine learning) techniques fail. Construct a stock trading software system that uses current daily data. Some limitations/constraints: We use daily data. This is not an HFT course, but many of the concepts here are relevant. We don't interact (trade) directly with the market, but we will generate equity allocations that you could trade if you wanted to. Prerequisites and Requirements Students should have strong coding skills and some familiarity with equity markets. No finance or machine learning experience is assumed. Note that this course serves students focusing on computer science, as well as students in other majors such as industrial systems engineering, management, or math who have different experiences. All types of students are welcome! The ML topics might be "review" for CS students, while finance parts will be review for finance students. However, even if you have experience in these topics, you will find that we consider them in a different way than you might have seen before, in particular with an eye towards implementation for trading. Programming will primarily be in Python. We will make heavy use of numerical computing libraries like NumPy and Pandas. What Will I Learn? P5: Build a Digit Recognition Program In this project, you will use what you've learned about deep neural networks and convolutional neural networks to create a live camera application or program that prints numbers it observes in real time from images it is given. First, you will design and test a model architecture that can identify sequences of digits in an image. Next, you will train that model so it can decode sequences of digits from natural images by using the Street View House Numbers (SVHN) dataset. After the model is properly trained, you will then test your model using a live camera application (optional) or program on newly-captured images. Finally, once you obtain meaningful results, you will refine your implementation to also localize where numbers are on the image, and test this localization on newly-captured images. Syllabus This course is composed of three mini-courses: Mini-course 1: Manipulating Financial Data in Python Mini-course 2: Computational Investing Mini-course 3: Machine Learning Algorithms for Trading Each mini-course consists of about 7-10 short lessons. Assignments and projects are interleaved. Fall 2015 OMS students: There will be two tests - one midterm after mini-course 2, and one final exam.
COURSE
Data Visualization and D3.js
Udacity
Learn the fundamentals of data visualization and practice communicating with data. This course covers how to apply design principles, human perception, color theory, and effective storytelling to data visualization. If you present data to others, aspire to be an analyst or data scientist, or if you’d like to become more technical with visualization tools, then you can grow your skills with this course. The course does not cover exploratory approaches to discover insights about data. Instead, the course focuses on how to visually encode and present data to an audience once an insight has been found. This course is part of the Data Analyst Nanodegree. Why Take This Course? Learn by doing! You will analyze existing data visualization and create new ones to learn about the field. At it’s core, data visualization is a form of communication. Learn how to be a great communicator and how to enable readers to walk away from your graphics with insight and understanding. This course also makes use of open web standards (HTML, CSS, and SVG) to create data visualizations. You can also learn how to... communicate clearly with the best visual representation of your data tell stories, spark discussion, and create calls to actions for readers design graphics like ones from the NYTimes and other media companies how to use open web technologies to create an online portfolio of your work use visualization libraries (dimple.js and D3.js) to create graphics Prerequisites and Requirements Regardless of your programming background, you can learn about data visualization and design principles in Lesson 1a and Lesson 2a without the following recommended background. To succeed in this course, you should to be familiar with basic programming principles, including data types (strings, arrays, booleans, etc.), if else statements, and for loops. You should also be able to describe concepts like functions and objects. Our Intro to Computer Science and Programming Fundamentals with Python courses are great places to get started. Basic knowledge of HTML and CSS (structuring and styling a web page) is not required but highly recommended. We suggest taking the Intro to HTML and CSS course if you have no experience with HTML or CSS. This course is unique in that the final project can be completed using either dimple.js or d3.js. The visualization library, dimple.js, is easier to use than d3.js and requires less background knowledge. Furthermore, a graphic can be created in considerably fewer lines of code using dimple.js as opposed to d3.js. So why should you learn d3.js? Data Driven Documents (d3.js) allows you to build highly customized graphics. If you would like to gain more technical skills and learn more about Javascript and open web standards, then you should complete Lesson 3 and Lesson 4 in order to prepare for the final project. If you would like to complete the final project using d3.js, you should have some experience reading and using documentation. For example, you should be able to code a for loop in Javascript or be able to look up the syntax to work with strings and arrays in Javascript. We recommend taking the Javascript Basics course if you have little to no experience with Javascript. Syllabus Lesson 1a Visualization Fundamentals (2 hours) Learn about the elements of great data visualization. In this lesson, you will meet data visualization experts, learn about data visualization in the context of data science, and learn how to represent data values in visual form. Lesson 1b D3 Building Blocks (4 hours) Learn how to use the open standards of the web to create graphical elements. You’ll learn how to select elements on the page, add SVG elements, and how to style SVG elements. Make use of all the Instructor Notes throughout this lesson if you have little to no experience with HTML and CSS. Mini-Project 1: RAW Visualization (2 hours) Create a data visualization using a software of your choice. We will provide recommendations for visualization software as well as data sets. We want you to get right into making data visualization so here’s your first chance! Lesson 2a Design Principles (2 hours) Which chart type should I use for my data? Which colors should I avoid when making graphics? How do I know if my graphic is effective? Investigate these questions, and learn about the World Cup data set which will be use throughout the rest of the course. Lesson 2b Dimple.js (4 hours) Learn how to create graphics using the Dimple JavaScript library. You will learn about this library as a gentle coding introduction before learning about D3.js. You will be able to produce great graphics with minimal code, and all of your graphics will come with interactivity without any extra effort on your part. Dimple, it's simple! Mini-Project 2: Take Two (2-5 hours) Find an existing data visualization, critique it for what it does well and what it doesn’t do well, and finally, recreate the graphic using a software tool of your choice. We recommend using Dimple.js, which is covered in Lesson 2b, but we don’t want you to feel constrained by the choice of tools. Use any tool that works for you. Special Note At this point in the course, you can start the final project. The remaining content of the course covers narrative structures, types of bias, and maps. All of the code in Lesson 3 and Lesson 4 pertains to d3.js. If you'd like to learn d3.js and complete the final project using d3.js, then please continue. If you prefer to stop, you can complete the final project using dimple.js. Lesson 3 Narratives (5 hours) Learn how to incorporate different narrative structures into your visualizations and code along with Jonathan as you create a graphic for the World Cup data set. You’ll learn about different types of bias in the data visualization process and learn how to add context to your data visualizations. By the end of this lesson, you’ll have a solid foundation in D3.js. Lesson 4 Animation and Interaction (5 hours) Static graphics are great, but interactive graphics can be even better. Learn how to leverage animation and interaction to bring more data insights to your audience. Code along with Jonathan once again as you learn how to create a bubble map for the World Cup data set. Final Project: Making an Effective Data Visualization (2 hours or more) You will create a data visualization that conveys a clear message about a data set. You will use dimple.js or d3.js and collect feedback along the way to arrive at a polished product. NOTE: As a free student, you are welcome to complete the project to showcase your learning; however, only students enrolled in the Data Analyst Nanodegree are able to submit the final project for review and certificate. Interested in enrolling? Find out more!
COURSE
Product Design
Udacity
There is nothing more powerful than an idea whose time has come. This course is designed to help you materialize your game-changing idea and transform it into a product that you can build a business around. Product Design blends theory and practice to teach you product validation, UI/UX practices, Google’s Design Sprint and the process for setting and tracking actionable metrics. Why Take This Course? Over the years, Silicon Valley startups have developed a series of frameworks and best practices for product design. Through startup case studies and interviews with industry experts, we want to bring you the best of Silicon Valley with lessons you can apply to influence the design of your mobile or web app. By the end of the course, you will know how to perform a Google Design Sprint (developed at Google Ventures and exclusively taught in this course) to design, prototype and test your ideas. You will also learn to design low fidelity mockups for your product and capture appropriate metrics. Prerequisites and Requirements This course has no formal prerequisites. You just need to have a problem to solve and be open to feedback! What Will I Learn? P1: Validated Product Design This project will help you design a product people will love. By the end of this project, you will be able to summarize your product idea, build out wireframes or prototypes, articulate what you learned from user testing, and highlight metrics that will be important to measure for your product. Syllabus Lesson 1: Ideation & Validation Life's too short to build products no one wants. This lesson will help you develop, validate and refine your ideas to ensure you’re building for a product/market fit. Through case studies and interviews with founders, product experts, and investors, you will learn how to efficiently conduct user research and build an entrepreneurial mindset. Lesson 2: UI/UX They say good design shrinks the gap between what a product does and why it exists. This lesson takes you beyond visual style to understand material design, building for accessibility, user flows and personas. You’ll hear about how startups make design decisions and learn from senior designers at Google on how they use design to emphasize the purpose of their products. By the end of the lesson, you will analyze the user experience of another product and start documenting a user flow for your own product. Lesson 3: Design Sprint Created by Google Ventures, the Design Sprint Process is widely used by teams seeking to design, prototype, and test their ideas with customers. In this lesson, Google’s leading Design Sprint Master will help you go through all the steps required to validate your ideas and build mockups of your product. You will also get a first-hand look at how design sprints happen at Udacity and how you can design & conduct your own. Lesson 4: Key Metrics In the final lesson, you will learn to identify common metrics for websites and apps relating to traffic, customer satisfaction, and engagement. You will learn tools that can be used to monitor metrics and examples from startups on what metrics not to measure. At the end of the lesson, you will identify actionable metrics that will work best for your own product.
COURSE
Technical Interview
Udacity
Are you ready to conquer your next interview? To succeed, you need to understand the expectations. Virtually all technical interviews follow a very set pattern: you get asked a very specific type of question, you're required to have very specific knowledge, and you're expected to answer—and interact with your interviewer—in a very particular way. Knowing this in advance, and preparing accordingly, is the key to success. This course was designed to give you what you need to ace a technical interview. Included are: videos that walk you through the algorithms and data structures concepts commonly asked in technical interviews an explanation of efficiency, and an explanation of how it relates to topics covered throughout the class practice problems and quizzes to test your understanding a mock interview with a breakdown explaining how interviewers expect you to explain your thought process curated links to outside resources, including a special link to live practice interviewing with other Udacity students on Pramp if you’re a Nanodegree student, a final project where you can answer interview questions and get feedback from a trained reviewer. The goal of this course is to prepare you for a real technical interview, so we focus on the material you'll actually be expected to do. Why Take This Course? This course provides an introduction to topics that often show up on technical interviews. It is aimed at students who have never taken a course in algorithms and data structures, but want to learn the material. It can also be used to refresh on these topics for those who have seen them before. In addition to video explanations, there are plenty of examples and discussions of the intricacies of different approaches. This course is distinct from other similar offerings on Udacity. It is a precursor to the “Intro to Algorithms” course, and complimentary to the Interviewing Course listed in most career-focused Nanodegrees. This course is focused on explaining the technical content that show up in interviews, while the other course is more centered on behavioral questions and how to act in an interview. Prerequisites and Requirements Basic knowledge of Python Familiarity with basic algebra Syllabus Introduction and Efficiency Start off with a basic introduction to topics covered in this course and the overall content structure, including an explanation of expected Python knowledge. Then, dive in with the definition of efficiency in a computer science context, as well as an explanation of the notation commonly used to describe efficiency. Practice describing efficiency from code snippets. List-Based Collections Learn the formal definition of a list in computer science, and see definitions and examples of list-based data structures, arrays, linked lists, stacks, and queues. Examine the efficiency of common list methods, and practice using and manipulating these data structures. Searching and Sorting Explore how to search and sort with list-based data structures, including binary search and bubble, merge, and quick sort. Examine the efficiency of each and learn how to use recursion in searching and sorting. See and write examples of these methods, as well as more sorting algorithms like insertion sort. Maps and Hashing Understand the concepts of sets, maps (dictionaries), and hashing. Examine common problems and approaches to hashing, and practice with examples of hash tables and hash maps. Trees Learn the concepts and terminology associated with tree data structures. Investigate common tree types, such as binary search trees, heaps, and self-balancing trees. See examples of common tree traversal techniques, examine the efficiency of traversals and common tree functions, and practice manipulating trees. Graphs Examine the theoretical concept of a graph and understand common graph terms, coded representations, properties, traversals, and paths. Practice manipulating graphs and determining the efficiency associated with graphs. Case Studies in Algorithms Explore famous computer science problems, specifically the Shortest Path Problem, the Knapsack Problem, and the Traveling Salesman Problem. Learn about brute-force, greedy, and dynamic programming solutions to such problems. Technical Interviewing Techniques Learn about the “algorithm” for answering common technical interviewing questions. See how to clarify and explain practice interview questions using the concepts taught in this course, and get tips for giving interviewers exactly what they’re looking for in an interview. Practice Interview Use Pramp to meet with another Udacity student and get live technical interview practice.
COURSE
App Monetization
Udacity
There is no higher form of user validation than having customers support your product with their wallets. However, the path to a profitable business is not necessarily an easy one. This course blends instruction with real life examples to help you effectively develop, implement, and measure your monetization strategy, iterating on the model as appropriate. This course is part of our Tech Entrepreneur Nanodegree Program, click here to learn more. Why Take This Course? Google Developer Relations has worked with thousands of developers in hundreds of startups to help them build successful apps. Along the way, they’ve identified common themes that contribute to successful monetization strategies. This course combines this expertise with insights from leading startups in multiple industries. From ecommerce to games, this course will guide you through the best practices and principles for monetizing your app. By the end of this course, you’ll be able to: Choose & implement a monetization strategy relevant to your product Set performance metrics & monitor the success of a strategy Know when it might be time to change methods Prerequisites and Requirements This course has no formal prerequisites, but you will get a lot more out of the instruction and exercises if you’ve got a product design, or you’ve completed Product Design before enrolling in this course. What Will I Learn? P2: Monetization Plan This project will help you figure out how your product will make money! With this project, you’ll identify how your product will generate revenue (your monetization strategy) and dig into the details of implementing that strategy and your rationale for choosing it. Syllabus Lesson 1: Introducing Monetization Developing an appropriate monetization strategy is comparable to finding the product/market fit for a new idea. This lesson will get you started on the path to finding that strategy by helping you think about profitability from the very beginning. You will also learn about different monetization models, profit margins, KPIs, and customer acquisition and retention. Lesson 2: Monetization Strategies They say nothing happens before you make your first dollar. This lesson takes a deep dive into monetization strategies for different platforms, covering freemium, subscription, eCommerce, and Ads across web, games, and native apps. You’ll learn about the tools startups use to implement these strategies and design a plan to execute a model for your own product. Lesson 3: Implement a Monetization Plan Monetization strategies change over time as the user base grows and the product evolves. In this lesson, you will choose and tailor a monetization strategy for your product and learn how to set up tracking to monitor its effectiveness. Using Google Analytics and other tracking tools, you will begin closely following and iterating based on behavior reports, crashes, exceptions, and app speed. Lesson 4: Optimize Your Model In the final lesson, you will learn how to react and re-engage users if your monetization strategies don’t originally work. Through a case study with Nir Eyal, you will see how product and monetization are closely tied and how the Hooked Model can be used to optimize your strategy. Case Study: Wufoo Learn how Kevin Hale got started with Wufoo (sold to SurveyMonkey).
Start your free Premium trialTry GO1 Premium free for 14 days. Easy signup, no commitment and, most importantly, instant access to 1000's of courses.
COURSE
JavaScript Testing
Udacity
In this course you'll learn how to write JavaScript applications with confidence, using the red-green-refactor workflow. You'll write comprehensive suites of tests that validate your application is functioning as intended at all times. You'll start by exploring how other industries use a variety of tests and the value it provides. You'll then start writing your very own tests, using the Jasmine testing framework. Finally, you'll start developing your very own address book application using the red-green-refactor workflow and explore a variety of scenarios including testing asynchronous functions. Why Take This Course? As your applications become more complex and you continue adding new features, you need to verify your additions haven't introduced bugs to your existing functionality. Automated testing provides this functionality and allows you to focus on. Prerequisites and Requirements You should be comfortable writing JavaScript and using its object-oriented programming features. If you need a refresher on these subjects, consider taking our JavaScript Basics and Object-Oriented JavaScript courses. What Will I Learn? P6: Feed Reader Testing In this project you are given a web-based application that reads RSS feeds. The original developer of this application clearly saw the value in testing, they’ve already included Jasmine and even started writing their first test suite! Unfortunately, they decided to move on to start their own company and we’re now left with an application with an incomplete test suite. That’s where you come in. Syllabus Overview This course consists of 2 lessons. In the first lesson, you'll discover the importance of testing and reconsider its purpose and the value it provides. In the second lesson, you'll explore the Jasmine testing framework write your own test suites while developing an address book application. Lesson 1: Rethinking Testing From education to aerospace, tests provide invaluable feedback to those that analyze the results. In this lesson, you'll learn all about the importance of testing, how to identify the expectations a test is attempting to validate and how to write expectations in code. Topics covered: What is a test? Validating opinions Identifying and defining expectations Writing expectations in code Lesson 2: Writing Test Suites JavaScript doesn't support testing natively, so you'll need a framework to provide the functionality you need. In this lesson, you'll get an introductions to the Jasmine testing framework and use the red-green-refactor workflow to begin development on an address book application. Topics covered: Introduction to Jasmine Writing suites, specs and tests The red-green-refactor workflow cycle Testing asynchronous functionality
COURSE
Grand Central Dispatch (GCD)
Udacity
Many times your apps need to run lengthy operations in the background, like downloading data, but you don't want these operations to interfere with your UI. Apple's GCD (long form: Grand Central Dispatch) framework allows you to create asynchronous apps for iOS, ensuring smooth a smooth user experience in situations like the one mentioned above. Why Take This Course? Almsot all Apps consume data from web services, and therefore must use background threads for these lengthy operations. Even though we provide a black box solution for concurrency in the iOS Networking with Swift course, it is important that you understand how concurrency works in iOS. This knowledge is vital to deliver Apps that won't be rejected from the App Store and also provide a great user experience. On top of that, GCD is a frequent topic in iOS job interviews. Prerequisites and Requirements To be successful in this course, you should be comfortable programming in Swift, and understand closures. You can learn these skills in our Swift Syntax course. Familiarity with The Hitchhiker's Guide to the Galaxy and The Matrix are also recommended in order to understand the jokes in this course. Syllabus Lesson 1: Closures Reloaded In this chapter we will revisit the concept of closures in Swift. We need to learn a few properties of closures that we bypassed in Swift Syntax. These are vital when dealing with GCD. You will put you new knowledge of closures to test in several playgrounds. By the end of this lesson you will be able to drop things like, "Closures are first class types that capture their lexical environment" in casual conversations and impress fellow nerds. Even better: you will actually know what the heck you're talking about! Lesson 2: Grand Central Dispatch Here you meet our main antagonist: Apple's open source library Grand Central Dispatch. GCD is an enormous library, so we will concentrate on its core features: how it allows you to send tasks to the background and (equally important) to the foreground. When you finish this lesson you will have a sound knowledge of how and what you can send to the background and what must always run in the foreground. Lesson 3: Sample App Talk is cheap. Show me the code! -- Linus Torvalds. In this chapter you will create a simple App that downloads huge images (the easiest way to block the UI). You will apply your newly acquired knowledge to send this network lengthy task to the background in 2 different ways. By the end of this lesson you will know how to run closures in the background, design methods that take a completion closure and understand the code in the black box in the Networking course.
COURSE
Intro to iOS App Development with Swift
Udacity
In this course we will build an iPhone app that records a conversation between you and a friend, and then makes your voices sound like a Chipmunk or Darth Vader. This course will introduce you to iOS app development in Swift, a new programming language from Apple, and serves as your launching point into the iOS Developer Nanodegree. Why Take This Course? This course will set you on your way to becoming an iOS Developer, where you’ll establish a basic understanding of the iOS ecosystem. You’ll also have working knowledge of Swift, Apple’s custom programming language created exclusively for the mobile developer. Prerequisites and Requirements This course assumes prior programming experience. Specifically, you should have a strong understanding of programming concepts like variables, if statements, loops, functions, and classes. Lesson 1 of Intro to Computer Science and Programming Foundations with Python are good courses to take if you are completely new to programming. You will also need access to a Mac computer running OS X 10.10 or later. We have designed this course such that you will not need a physical device (i.e. an iPhone or an iPad) to build your app. We will be using a simulator on your mac that will imitate the features of a phone on your computer. Towards the end of the course we will provide instructions on how to download your app on an iPhone (in case you do have access to a physical device.) What Will I Learn? Pitch Perfect Ever wondered what you’d sound like as a Chipmunk or Darth Vader? Wonder no more! In this first project, you’ll build an app that records a user’s voice and then plays the modulated audio through a variety of filters. Syllabus Lesson 1: Introduction and Xcode Introduction to Swift and Xcode, taking the first steps in becoming an iOS developer. Lesson 2: AutoLayout and Buttons Learn Storyboard, AutoLayout, UIButtons and UILabels. Start developing the Pitch Perfect App and creating the user interface. Lesson 3: ViewController & Multiple Views View Controllers, View Controller Lifecycle, and Multiple Views. Learn how to react to touch events and change the user interface based on those events. Lesson 4: Delegation and Recording Introduction to AVAudioRecorder, Delegation, and programatic segues. Setup audio recording in the Pitch Perfect App. Lesson 5: Playback and Effects Setup audio playback including rate, pitch, echo, and reverb. Learn about UIStackViews and class extensions. Final App Submission (1 hour) In this final lesson, you will ensure that your app works according to a rubric we have designed, and will also have an opportunity to add new features to your app. We will also share with you a Code Review document that contains suggestions from an external reviewer on how to improve your code. We will request that you implement those suggestions to enhance your code and make it ready for the app store. Finally, to complete the course, you will submit your app to a Udacity coach for a thorough evaluation of your work.
COURSE
Linux Command Line Basics
Udacity
We have built this course for beginners who have no experience with the Linux system and the command-line interface. In this course, you'll learn the basics of the command line interface of a Linux server: the terminal and shell (GNU Bash). This course includes an introduction to files and directories in the Linux filesystem. Why Take This Course? Most servers on the Internet today run on Linux or other Unix-like systems. Installing, configuring, and troubleshooting often relies on the command line interface. This, accordingly, is foundational web knowledge, and in fact many of our intermediate and advanced courses rely on a familiarity with the command-line interface to run servers, work with version control systems and more. Prerequisites and Requirements To take this course, you should have beginner-level experience in a programming languages such as Python or JavaScript. While this course does not involve doing any programming, it does use concepts that are familiar to the beginning programmer such as "function", "expression", and "string". Note: This course is intended for beginners to the shell environment. If you have done shell scripting or other extensive use of the shell before, this course will probably be too introductory for you. You might want to check out our Configuring Linux Web Servers course. What Will I Learn? Project: Linux Server Configuration You will take a baseline installation of a Linux distribution on a virtual machine and prepare it to host your web applications, to include installing updates, securing it from a number of attack vectors and installing/configuring web and database servers. Note: If you have no experience working in the shell we recommend starting with Linux Command Line Basics. Otherwise, you can jump straight into Configuring Linux Web Servers. Syllabus Lesson 1: Get Into the Shell In this lesson, you'll learn about the terminal user interface and how you can interact with a Linux server using shell commands. Lesson 2: Shell Commands There are different kinds of shell commands that work with the terminal in different ways. This lesson also covers the use of the Linux manual (manpages) to expand your knowledge of shell commands. Lesson 3: The Linux Filesystem Working with files and directories is a big part of using the shell. In this lesson you'll learn basic commands for interacting with the filesystem.
COURSE
Reinforcement Learning
Udacity
You should take this course if you have an interest in machine learning and the desire to engage with it from a theoretical perspective. Through a combination of classic papers and more recent work, you will explore automated decision-making from a computer-science perspective. You will examine efficient algorithms, where they exist, for single-agent and multi-agent planning as well as approaches to learning near-optimal decisions from experience. At the end of the course, you will replicate a result from a published paper in reinforcement learning. Why Take This Course? This course will prepare you to participate in the reinforcement learning research community. You will also have the opportunity to learn from two of the foremost experts in this field of research, Profs. Charles Isbell and Michael Littman. Prerequisites and Requirements Before taking this course, you should have taken a graduate-level machine-learning course and should have had some exposure to reinforcement learning from a previous course or seminar in computer science. Additionally, you will be programming extensively in Java during this course. If you are not familiar with Java, we recommend you review Udacity's Object Oriented Programming in Java course materials to get up to speed beforehand. What Will I Learn? P4: Train a Smartcab to Drive In the not-so-distant future, taxicab companies across the United States no longer employ human drivers to operate their fleet of vehicles. Instead, the taxicabs are operated by self-driving agents — known as smartcabs — to transport people from one location to another within the cities those companies operate. In major metropolitan areas, such as Chicago, New York City, and San Francisco, an increasing number of people have come to rely on smartcabs to get to where they need to go as safely and efficiently as possible. Although smartcabs have become the transport of choice, concerns have arose that a self-driving agent might not be as safe or efficient as human drivers, particularly when considering city traffic lights and other vehicles. To alleviate these concerns, your task as an employee for a national taxicab company is to use reinforcement learning techniques to construct a demonstration of a smartcab operating in real-time to prove that both safety and efficiency can be achieved. Syllabus Reinforcement Learning Basics Introduction to BURLAP TD Lambda Convergence of Value and Policy Iteration Reward Shaping Exploration Generalization Partially Observable MDPs Options Topics in Game Theory Further Topics in RL Models
COURSE
How to Make an iOS App
Udacity
Do you have some experience building apps for the iPhone or iPad and want to build an app from the ground up, but don't know where to begin? Look no further! In this course, you'll learn the process of building an iOS app, from brainstorming ideas to publishing on the App Store. Why Take This Course? Building an app from scratch is a time-consuming, but rewarding process. Don't let the length of the lessons fool you! This course is unique in that you'll spend most of your time outside of the classroom, working on your app. We'll point you in the right direction to find resources and make progress, but it will be up to you to implement. By the end of the course, you'll have built you very own custom iOS app, and have the confidence to do it all again. Prerequisites and Requirements Enrolling in this course assumes you have prior iOS development experience. The material won't cover the technical aspects of app development, instead serving as a guide through the process of building an app. Specifically, the course was built to support the final project in the iOS Developer Nanodegree and assumes mastery of the concepts taught in the following courses: UIKit Fundamentals iOS Networking with Swift iOS Persistence and Core Data Please also note that submitting to the App Store, or loading your app to a physical device requires enrollment in the iOS Developer Program. What Will I Learn? You Decide! Landing a job as an iOS Developer requires more than technical skills; it requires creativity and innovation. Drawing on everything you’ve learned so far in the Nanodegree, you'll now dream up, design, and code your own custom app. Syllabus Lesson 1: Research In this first lesson, you'll brainstorm and vet multiple app ideas. You'll begin to think about the UI elements used in each, get user feedback on the designs, as well as start thinking about relevant web APIs and libraries to use. Lesson 2: Build In this lesson, you'll choose an idea to pursue and build it! We'll share tips for getting started, dealing with code that doesn't work, and how to submit to the App Store. Lesson 3: Reflect In this last lesson, you'll reflect on the process: what went well, and what you might do differently next time. Recognizing and learning from mistakes is what makes you a better developer!
COURSE
Intro to Hadoop and MapReduce
Udacity
The Apache™ Hadoop® project develops open-source software for reliable, scalable, distributed computing. Learn the fundamental principles behind it, and how you can use its power to make sense of your Big Data. Why Take This Course? How Hadoop fits into the world (recognize the problems it solves) Understand the concepts of HDFS and MapReduce (find out how it solves the problems) Write MapReduce programs (see how we solve the problems) Practice solving problems on your own Prerequisites and Requirements Lesson 1 does not have technical prerequisites and is a good overview of Hadoop and MapReduce for managers. To get the most out of the class, however, you need basic programming skills in Python on a level provided by introductory courses like our Introduction to Computer Science course. To learn more about Hadoop, you can also check out the book Hadoop: The Definitive Guide. What Will I Learn? Final Project In this project you will work with discussion forum (also sometimes called discussion board) data. It is one type of user generated content that you can find all around the web. Most popular websites have some kind of a forum, and the things you will do in this project can transfer to other similar projects. Syllabus Lesson 1 What is "Big Data"? The dimensions of Big Data. Scaling problems. HDFS and the Hadoop ecosystem. Lesson 2 The basics of HDFS, MapReduce and Hadoop cluster. Lesson 3 Writing MapReduce programs to answer questions about data. Lesson 4 MapReduce design patterns. Final Project Answering questions about big sales data and analyzing large website logs.
COURSE
Data Analysis with R
Udacity
Exploratory data analysis is an approach for summarizing and visualizing the important characteristics of a data set. Promoted by John Tukey, exploratory data analysis focuses on exploring data to understand the data’s underlying structure and variables, to develop intuition about the data set, to consider how that data set came into existence, and to decide how it can be investigated with more formal statistical methods. If you're interested in supplemental reading material for the course check out the Exploratory Data Analysis book. (Not Required) This course is also a part of our Data Analyst Nanodegree. Why Take This Course? You will... Understand data analysis via EDA as a journey and a way to explore data Explore data at multiple levels using appropriate visualizations Acquire statistical knowledge for summarizing data Demonstrate curiosity and skepticism when performing data analysis Develop intuition around a data set and understand how the data was generated. Prerequisites and Requirements A background in statistics is helpful but not required. Consider taking Intro to Descriptive Statistics prior to taking this course. Relevant topics include: Mean, median, mode Normal, uniform, and skewed distributions Histograms and box plots Familiarity with the following CS and Math topics will help students: Variable assignment Comparison and logical operators ( <, >, <=, >=, ==, &, | ) If else statements Square roots, logarithms, and exponentials Syllabus Lesson 1: What is EDA? (1 hour) We'll start by learn about what exploratory data analysis (EDA) is and why it is important. You'll meet the amazing instructors for the course and find out about the course structure and final project. Lesson 2: R Basics (3 hours) EDA, which comes before formal hypothesis testing and modeling, makes use of visual methods to analyze and summarize data sets. R will be our tool for generating those visuals and conducting analyses. In this lesson, we will install RStudio and packages, learn the layout and basic commands of R, practice writing basic R scripts, and inspect data sets. Lesson 3: Explore One Variable (4 hours) We perform EDA to understand the distribution of a variable and to check for anomalies and outliers. Learn how to quantify and visualize individual variables within a data set as we begin to make sense of a pseudo-data set of Facebook users. While the data set does not contain real user data, it does contain a wealth of information. Through the lesson, we will create histograms and boxplots, transform variables, and examine tradeoffs in visualizations. Problem Set 3 (2 hours) Lesson 4: Explore Two Variables (4 hours) EDA allows us to identify the most important variables and relationships within a data set before building predictive models. In this lesson, we will learn techniques for exploring the relationship between any two variables in a data set. We'll create scatter plots, calculate correlations, and investigate conditional means. Problem Set 4 (2 hours) Lesson 5: Explore Many Variables (4 hours) Data sets can be complex. In this lesson, we will learn powerful methods and visualizations for examining relationships among multiple variables. We'll learn how to reshape data frames and how to use aesthetics like color and shape to uncover more information. Extending our knowledge of previous plots, we'll continue to build intuition around the Facebook data set and explore some new data sets as well. Problem Set 5 (2 hours) Lesson 6: Diamonds and Price Predictions (2 hours) Investigate the diamonds data set alongside Facebook Data Scientist, Solomon Messing. He'll recap many of the strategies covered in the course and show how predictive modeling can allow us to determine a good price for a diamond. As a final project, you will create your own exploratory data analysis on a data set of your choice. Final Project (10+ hours) You've explored simulated Facebook user data and the diamonds data set. Now, it's your turn to conduct your own exploratory data analysis. Choose one data set to explore (one provided by Udacity or your own) and create a RMD file that uncovers the patterns, anomalies and relationships of the data set.
COURSE
App Marketing
Udacity
Without customers, your business does not exist. Marketing helps you understand your potential user and focus your product on their needs. This course will help you organize a strategy of identifying your perfect user, find ways to connect with them and what you’ll say when you find them. This covers research, planning, execution and most importantly how to grow your user base. This course is part of our Tech Entrepreneur Nanodegree Program, click here to learn more. Why Take This Course? You’re going to come up with a plan to acquire users and grow! By the time you’re done, you will have a robust marketing plan, including a slide deck with a description of your value to your customers, how you stack up against competitors, who your target audience is, and to grow your customer base. Prerequisites and Requirements This course has no formal prerequisites, and you can complete this course using our aBarkment app as an example. But if you have your own product idea, we encourage you to explore our Product Design and Rapid Prototyping courses. You can leverage the mockups from those course to get even more out the instruction and exercises in this course. What Will I Learn? P4: Marketing & Distribution Plan With this project, you’re going to come up with a plan to acquire users and grow! By the time you’re done, you will have a robust marketing plan, which will also give you a lot of material for your final capstone project. Including a slide deck with a description of your value to your customers, how you stack up against competitors, who your target audience is, and how you plan to get distribution. Syllabus Lesson 1: Understand the User Learn to define and create a targeted marketing plan for specific user segments. Analyze your competitive advantages and disadvantages through market segmentation and the five level of market competition and learn how to position your product. Conduct competitive analysis in order to create your unique value proposition. Lesson 2: Pre-launch Create marketing goals in order to focus your marketing plan. You’ll start thinking about your distribution plan and consider what keywords work best for your goals. You’ll also create the materials to help prepare you for launch and learn about your app listing page. Finally, you’ll learn about the beta-testing community, beta-testing groups, and prepare your landing pages. Lesson 3: Launch! Prepare, launch, execute, and gain your first users. You’ll outline a go-to-market strategy and gain the know-how to execute on it. You’ll learn SEO (search engine optimization) and ASO (app store optimization) skills as well as growth hacking tips to get your first 1000 users. Lesson 4: Customer Acquisition Learn about paid and free customer acquisition methods from AdWords, social marketing, email marketing and more. Lesson 5: Measurement Fundamentals Learn to use data to iterate and optimize your marketing plan.
COURSE
Rapid Prototyping
Udacity
Prototyping allows you to spend ten minutes — instead of ten hours — finding an amazing design for your product. This course will guide you through the iterative process of prototyping an app and conducting user research. You will start by making a low fidelity paper prototype, conducting research with users, and using that research to inform your next iteration. Together with InVision we’ll guide you through creating interactive prototypes. This means you don’t have to code an app before putting it in front of users! Along the way, you’ll learn how and where prototyping fits into your app design process and how you can use prototyping to become a better entrepreneur. Why Take This Course? Prototyping is an art that exists to save you time and money in the app development process. It allows you to identify design flaws quickly so you waste as little time as possible building a phenomenal app. By learning this art, you’ll create quality apps faster and have confidence in the viability of your products. By the end of the course, you’ll be comfortable with the prototyping process, be able to get quality user feedback, and use the feedback to create great apps. Prerequisites and Requirements This course has no formal prerequisites, but you will get a lot more out of the instruction and exercises if you’ve got a product idea. If you’ve completed our Product Design course, you can leverage your app mockups from that course to get a headstart in this one! What Will I Learn? P3: Interactive Prototype In this project, you’ll go through the iterative prototyping process – starting with a low fidelity prototype and using feedback to build a medium fidelity prototype. By the end, you’ll have an amazing prototype to share and a really insightful list of talking points for potential investors about the feedback from your UX research experiments. Syllabus You’ll learn basic paper prototyping, conducting user research, and understanding feedback on your app. You’ll also learn how to use InVision to create interactive medium-fidelity prototypes and conduct user research remotely. Finally, you will learn how to continue prototyping new features as you move further in the app development lifecycle and how to present your research to friends, investors, and anyone else who is interested in your work. Lesson 1: Low-Fidelity Prototypes & User Research In this lesson, you’ll learn the fundamentals of prototyping, as well as the process of making paper prototypes and presenting them to users. Lesson 2: Medium-Fidelity Prototypes with inVision In this lesson, you’ll learn how to incorporate feedback, make interactive prototypes using InVision, and how to conduct further user research remotely. Lesson 3: Lifelong Prototyping In this lesson, you’ll learn how to refine your prototypes further, how to involve prototyping and user research in new app features, and how to present your prototypes and research.
COURSE
Xcode Debugging
Udacity
"If debugging is the process of removing bugs, then programming must be the process of putting them in."Edsger W. Dijkstra Debugging is yin to programming's yang; you can't have one without the other. However, finding bugs in programs can be an incredibly frustrating and demotivating process for developers. This course will teach you a variety of techniques to help make debugging your code easier. Why Take This Course? Debugging is one of the most fundamental processes involved in writing software. Nobody writes perfect code, and job-ready developers should know how to find and fix programming errors. In this course, you'll learn standard methodologies for debugging software—especially for iOS applications. Additionally, you'll learn how to use Xcode’s debugging tools (breakpoints, LLDB, etc.) to squash those bugs! Prerequisites and Requirements This course assumes rudimentary iOS programming experience. You should be able to scan Swift code to identify methods and errors, and make minor changes to correct them. Syllabus Lesson 1A: Debugging, Printing, Logging In this lesson, you'll be introduced to the "So Many Bugs" app, which we'll use to solve coding mysteries throughout the course. You'll also learn about the debugging process, and how to use print statements to identify bugs. Lesson 1B: Stepping Through Code In this lesson, you'll learn how to use breakpoints to examine application state at any point during execution. Lesson 2A: LLDB and Breakpoint Actions In this lesson, you'll learn about LLDB (low-level debugger)—the debugging super tool. You'll be introduced to common LLDB commands, tips, and tricks. Lesson 2B: Breakpoints and Visual Tools In this lesson, you'll learn about exception and symbolic breakpoints, and how to debug your code using Xcode's visual debugging tools.
Find training fasterLooking for project management or sales training? Or a face-to-face first aid course? Your GO1 Training Assistant can help you find and book the right training for you – at the best price.
Content image