Programming Fundamentals | Kotlin And Android For Beginners!
3.8 (62 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
236 students enrolled

Programming Fundamentals | Kotlin And Android For Beginners!

Learn Kotlin, Android App Development, Android Studio, and Software Architecture from a Pro Developer; Beginner Friendly
3.8 (62 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
236 students enrolled
Created by Ryan Michael Kay
Last updated 9/2019
English
English [Auto]
Price: $19.99
30-Day Money-Back Guarantee
This course includes
  • 8 hours on-demand video
  • 13 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Assignments
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • The fundamentals of the Kotlin programming language for all platforms
  • Android Development for Beginners and Junior Developers
  • Useful but simple information on Functional Programming
  • Golden Principles of Software Architecture demonstrated in code (Modularity, IoC, SOLID and more)
Requirements
  • Effort. I write 90% of the code from scratch, you will be expected to follow along.
  • Patience. You will have to trust me that I am teaching you important things, and that it is worth typing out the examples with me (I know it sucks, but you will learn faster).
Description

This course serves as a comprehensive introduction to the fundamentals of writing clean, modular, scalable, and legible mobile applications using Kotlin and Android. Sections 1-5 will introduce the core concepts of the Kotlin programming language using very hands on coding lessons which can be completed by anyone with a browser and an internet connection. Sections 6 provides an overview of the basics of an Android application, and in section 7, we will build an entire app together using all of the best practices discussed in previous sections and more!

* This course is designed to be very beginner friendly. I am a self-taught developer who has spent over 1000 hours on youtube teaching people in both live and recorded content. Even if you're coding experience is limited, I will explain how to build things the right way, while using as little jargon as possible! In fact, I hate jargon -.-

* Almost Everything you have wanted to know about Dependency Injection, Modularity, Clean Architecture, Abstractions/Interfaces, Test Driven Development, and how to Design New Apps will be addressed in this course, with clear examples and use cases!


* I will not bull**** you by having you build a whole bunch of garbage Android apps using God Activities. You will write a lot of code, and you will write it well! It will be easy to change, easy to read, easy to test, and easy to maintain using the golden principles of good software architecture and design! When it comes to building Android applications, I actually practice what I preach. If you don't believe me, please visit my github account "BracketCove" for an idea of the quality of applications I have written.

So if you're ready to start your Android/Kotlin/Programming career from someone an obsessive perfectionist who loves explaining things with simple language and analogies, then you had better check this course out!

Who this course is for:
  • Absolute Beginners to Kotlin and/or Android Development with Kotlin
  • Junior/Intermediate/Senior Android Developers coming from Java
  • Those interested in Kotlin's basic and advanced features such as Coroutines
Course content
Expand all 40 lectures 07:52:25
+ Introduction and Course Overview
4 lectures 41:33

Update May 2019: When I first created this course, my intention was to use the try.kotlinlang.org editor, as discussed in this video. This meant that anyone with a browser can complete the lessons in this course. While sections 1-5 of this course will still  follow this same intention, sections 6, which contain material on Android Development, do require an actual IDE in order to complete them (preferably Android Studio). In that section I have specific lessons for downloading and user Android Studio, so please check them out once you are ready.

Topics:

- Overview of the broader topics in each part of this course

- Who this course is intended for

- What to expect

- Why I chose the topics I did

Preview 04:23

Update May 2019: When I first created this course, my intention was to use the try.kotlinlang.org editor, as discussed in this video. This meant that anyone with a browser can complete the lessons in this course. While sections 1-5 of this course will still  follow this same intention, sections 6, which contain material on Android Development, do require an actual IDE in order to complete them (preferably Android Studio). In that section I have specific lessons for downloading and user Android Studio, so please check them out once you are ready.


Topics:

- How to run the examples using only a browser (expect to be writing some damn code)!

- If you have an IDE though, use that instead.

Preview 01:32

Topics:

- A little bit of everything. We build a simple, but functional application in Kotlin.

Don't be concerned about memorizing anything at this point; I will discuss the things we do in detail later. Make effort and be patient. This is one of the more difficult videos!

Kotlin Syntax Practice for Beginners: Follow Along!
27:45

Topics:

- Best practices for learning new programming languages, tools, and concepts faster

Somewhat of a bonus video, but these are my top 4 tips for learning to code effectively. I won't lie to you though; the best programmers study almost every day. This video is on how to use your efforts more wisely.

How to Learn Programming Faster, and with Better Retention!
07:53
+ Storing and Creating Data: Constants, Mutability, Classes, and Properties
5 lectures 45:22

Please Note: This video is intended for beginners interested in learning a bit of computer science. If you're just here to learn Kotlin, go ahead and skip to the next video.

Topics:

- What is information?

- Von Neumann Architecture

- How do computers store information?

- How does binary fit in to things?

What is Information, and how do Modern Computers work with it?
05:17

Topics:

- Memory Space and Run Time

- Assignment  and References in Kotlin (Creating Objects and Named Addresses)

- Use References with caution!

Data Landscape: Memory Spaces and Named Addresses (References)
04:51

Topics:

- What is Immutability?

- When should I use val, or const val?

- Tips on when to use visibility modifiers to make your objects and functions as private as possible

How to use "val" and "const val" References to promote Immutability/Efficiency
07:31

Topics:

- When to use var type references in your program

- Why you should try to avoid doing so if at all possible

- A cool demo with Coroutines to demonstrate how programming with var type referencs and Shared Mutable State (Shared Changeable Data) can cause a computer to say that 1 + 1 = 43

Using "var" Reference Types, and the problems with Shared Mutable State!
06:59

Topics:

- How to build "Things" (objects)

- val and var properties

- normal classes and data classes

- Cohesion: The degree to which data and functions belong in a particular class (most people screw this up as beginners!)

Preview 20:44
As discussed in lecture #8, one of the most difficult technical challenges which programmers face, is dealing with Shared Mutable State (Shared change-able data). Our first defense against such problems, is to work with Immutable Data as often as possible.
Assignment #1: Creating, Instantiating, and Copying Immutable Data Models
3 questions
+ Processing Events and Data with Logic
5 lectures 58:39

Topics:

- Overview of this part of the course

- Control Logic versus Computation Logic


A Fundamental Divide: Computation and Control Logic
03:03

Topics:

- Computation Logic Best Practices

- How to use other people's code to avoid "reinventing the wheel"

- A bit of info on Functional Purity from Functional Paradigm Programming

Computing Data means Solving Problems
09:17

Topics:

- Best practices for Control Logic

- using if(...) and else(...) clauses

- Equality and comparisons "==" "<="

Controlling the Flow of Data
05:09

Topics:

- Using "Restrictions" on types, values, and functions to improve program design

- Event Driven Program Design basics

- Using sealed classes to represent restricted events with or without accompanying data

- Using enum classes to represent restrict sets of values

- A soft introduction to Lambda Expressions and using Function Types

Preview 20:07

Please note: There is an error in this video in the firstAndSecondNotValid(...): String {...} Function which has been corrected in the Repository code and resources. Thank you to my friend Wiktor for catching it!

Topics:
- How to design programs which are driven by functions as opposed to classes and shared mutable state

- General information on taking a more Functional approach to writing code when appropriate

Functional versus Imperative Program Style (mild introduction)
21:03
Carrying on with the theme of the previous assignment, you will write a simple Array to String program using a functional (as opposed to imperative) style solution. That means you may not use any run-time assignment statements!
Assign #2: Going Functional
3 questions
+ Simple and Effective Software Architecture
6 lectures 01:25:37

Topics:

- The problems that arise from not learning or applying the principles of good Software Design/Architecture

- What does bad Software Architecture look like?

- An overview of my top 3 principles for building applications properly: Separation of Concerns, Dependency Inversion, and Open/Closed

What is Software Architecture?
02:32

Topics:

- How to build programs the worst way possible; no separation of concerns!

- Separation of Functions

- Separation of Things (classes, objects, even groups of classes)

- What does MVP/MVC/MVVM have in common?

- What is the benefit of applying Separation of Concerns, explained with the simplest analogy I could think of: Sidewalks

Separation of Concerns
12:55

Topics:

- Using Interfaces effectively

- How to build Front End Contract Interfaces

- How to build a Back End Repository Pattern using Interfaces

- How to communicate with (fake) local and remote data sources through one interface

Dependency Inversion: Using Interfaces Effectively for Front End and Back End
32:07

Topics:

- What is the Open/Closed Principle all about?

- How to extend the functionality of existing sources (classes) without having to change them (sounds crazy, I know)

- How to achieve OCP by using Abstract Classes (Object Oriented Approach)

- How to achieve OCP by using Extensions Functions (Functional Approach)

Preview 10:44

Dependency Injection is likely the most deceptive topic I have come across as a developer; for it is truly one of the simplest ways to improve the modularity and testability of your applications. The thing is, Dependency Injection frameworks, such as Dagger 2, tend to be very complicated.

In this lesson you will come to understand that DI is very simple, and it does not actually require any libraries. As the scale of the applications you build increases, you may still wish to use a library (I do actually recommend Dagger 2, but only for very large projects!), but for any Junior-Intermediate level developer, I suggest practicing it without such tools.

Dependency Injection: How, What, and Why?
13:20

Dependency Injection is a means of separating code which creates and provides dependencies, from code which uses dependencies. While Constructor Injection is common and general good enough, there are many other ways to apply this separation. In this lesson, we will look at the Service Locator Pattern, which works and results in similar benefits to Constructor Injection.

Inversion of Control via the Service Locator Pattern
13:59
+ Designing and Proving Programs
2 lectures 25:11

Topics:

- The primary concept of testing by analogy

- How to test programs using JUnit

- Test coverage

Proving Programs with Tests (a light introduction to Testing)
17:14

Topics:

- What is Problem Domain Analysis?

- How to write Problem Statements and refine them further

- How to write User Stories

- How to go from User Stories to Architectural components of an application

Solving Problem (Domains) by Analysis
07:57
+ Introduction to Android Development w/ Android Studio
9 lectures 42:46

In this video, I discuss the topics which will be covered in section 6 of this course. Section 6 is intended to introduce the Android Studio IDE, along with some explanation of the most important basic topics for the student to understand, prior to creating Android Application. By the end of this section, system requirements permitting, the student is expected to deploy what may be their first ever Android Application!

Overview and Introduction to Section 6
02:20

In this lesson, I discuss the Android Studio IDE (Integrated Development Environment). IDE is a big fancy word for a "program which you make programs with", and for Android Development, there is no better option that Android Studio. I do briefly mention alternatives for those incapable of running it on their systems, but the truth is that having spent my first year and a have of Android Development using Eclipse + ADT, I do not suggest it unless absolutely necessary.

I've included the link to download AS from the official website in the external resources for this lesson.

Android Studio IDE: An Application for making Android Applications
02:52

The bad news is that you will need to learn XML in order to make Android Apps. The good news is that XML is by design, scarcely even a language. It is in the same family of HTML (Declarative/Markup Languages), but has even fewer rules. This lesson will introduce to you everything you need to know to become a master of XML, which is not much at all.

Please do not overthink XML, you will become very familiar with it in practice simply building things like XML based user interfaces (Layouts); discussed shortly.

XML: The Five Minute Language, Tags/Elements, Attributes, Namespaces
06:51

While it is technically possible to build an application and publish it without ever testing it on a physical device or emulator (virtual device), that would be quite stupid. In this lesson, I discuss necessary steps to set up either your own physical Android Device (such as a Nexus 5x), or an Emulator, in order to begin actually running your applications!

Please visit the link in the resources for more information on setting up your physical device to enable USB Debugging (USB Debugging is a fancy word for running your apps on your device via USB connection).

Physical and Virtual Devices in Android Studio, Developer Options, AVD Manager
05:09

In this lesson, I walk you through the initial process of creating a new Android Project in Android Studio. Once our new project is created, I discuss the project explorer panel, and the difference between an "Android Project" in Android Studio, versus a packaged "Android Application."

Now, some of you may be wondering how it is possible to write programs in pure Java, pure Kotlin, or anything in between. In the last part of this lesson, I briefly describe Android Studio's multi-stage compilation process, which allows for this behaviour, but at the cost of longer build times.

Creating an Android Project, Android Studio Basics, Mixed Kotlin + Java Projects
05:31

If you have experience creating GUI applications on any platform, then you will be familiar with the necessity of including everything from text, images, animations, videos, styling information, to raw data. In this lesson, I discuss the basics of the "res" directory, and its contents.

We also create a new Layout XML resource, which happens to be the primary tool for creating the User Interface on Android.

Introducing Resources, res directory, and Layouts for building the UI
05:59

Of the various files which make up an Android Project, few are as important as the AndroidManifest XML file. This configuration file contains information and settings for many more things than I care to mention, but in this lesson, I discuss the basics.

We also create a new "Activity", which for beginners, I would define as a primary user interface screen (however, I do not actually advise them to be used for that purpose for advanced developers). When creating a new Activity, it is important to realize that the wizard also adds an entry to the AndroidManifest. Failing to do so would result in a crash if one attempting to launch an unregistered Activity.

The AndroidManifest Configuration File, Creating an Activity
06:35

At first glance, Gradle appears to be a very cryptic and confusing tool, even for some intermediate developers. While getting used to Gradle syntax and configurations is not exactly easy, the good news is that you can make it very far without having to actually change the default Gradle implementation much at all.

In this lesson, I discuss the most important files Gradle files, the Project Level, and Module Level "build.gradle" files. Now, I must once again ask that you not worry too much about trying to memorize this information. Over time you will become comfortable with adding new dependencies and tools.

Gradle Build Automation Tool Basic: Great Defaults, Easy Customization
04:39

The moment of truth, and the first real step towards becoming an Android Developer, lies in deploying an Application to a Device. Whether you use a Physical or Virtual Device is not so important; let's build and deploy an App!

Deploying a HelloWorld Application to a Physical Device or Emulator on Android
02:50
+ Let's Build An Android App In Kotlin
9 lectures 02:53:17

In this video, we discuss/implement:

- An overview of the App we'll be building

- Initial Project Creation

- Gradle Configuration for Kotlin and Coroutines.

Overview, Project Creation, and Gradle Configuration
06:59

In this video we discuss/implement:

- How Problem Domain Analysis, Problem Statements, and User Stories can be used as a tool for guiding the construction of Domain Objects and Interfaces

- Interfaces for our Back End Facade, and sub-systems including a Validator and an Evaluator

- Creating and Discussing a ResultWrapper (Either Monad)

Problem Domain Analysis And Interfaces, Repository/Facade
18:35

In this video we discuss/implement:

- ContraintLayout using Chains, Guidelines, and Weight

- Custom View Styles using styles.xml

- Custom Drawables for button backgrounds

XML User Interface W/ ConstraintLayout Guidelines, Chains, Styles And More!
29:29

In this video, we discuss/implement:

- Creating a "Contract" interface and Event handler using Interfaces and Sealed Classes

- View Binding via Kotlin Synthetic Properties (no findViewById() required)

- Simple way to manage temporary UI State in an Activity

View W/ Activity, Front End Contract And Event Handling W/ Sealed Class
25:22

In this video we discuss/implement:

- Test Driven Development for a Presentation Logic Class
- JUnit 5 and lots of discussion/best practices for testing

- Coroutines Implementation using the launch coroutine builder

Presentation Logic W/ Test Driven Development And Coroutines
32:47

In this lesson, we discuss/implement:

- A Facade Pattern using Test Driven Development

Facade/Repository Implementation W/ T.D.D., Suspend Functions
18:05

In this lesson, we discuss/implement:

- Validation Logic using many different Kotlin String manipulations and RegEx (Regular Expression)
- Calculator Logic w/ more of the same
- How to change to a background thread for Network/IO operations using the withContext() Coroutine Builder

- Lots of Tests (although we skip traditional TDD to save time)

Validator, Calculator, Background Thread Processing W/ withContext() Coroutine
23:54

In this lesson, we discuss/implement:

- Build Logic (Dependency Injection) in a simple hand-written Kotlin object.

Simple, Libary-Free Build Logic (Dependency Injection)
03:45

In this lesson, I discuss the nature of the final assignment for this course; where your task is to fix a broken application by any means necessary (probably using we covered in this course ;) ).

To make the final challenge easier, this video includes an explanation of reading Error Stack Traces/Logs, as well as using Android Studio's Debugging Tool.

Please Note: You will need either a Device or an Emulator to complete the final assignment!

Final Assignment Overview, Reading Error Logs, Using Android Studio's Debugger
14:21
In this final assignment, your task will be to find and fix the three errors present in the "debugchallenge" branch of the course samples repository. Please see Lesson #40 for further explanation, and a link to the appropriate repository.
Final Assignment: Debug Challenge
3 questions