Ultimate Coding Course for Web App and Android Development

Install Android Studio 3.0 preview, enable Cartland support, create a new project, adjust module and compiler settings, and resolve initial syncing issues to get started.

Install the Cartland plugin in Android Studio 2.3.2 or earlier. Convert Java files to Cartland and configure the Cartland dependencies in Gradle, then sync the project.

Explore Cartland variables: basic syntax and usage, differences from Java, and topics like eight primitives, strings, ranges, nullable types, conversions, and type casting with binary, hexadecimal, and bitwise operators.

Discover what variables are, how to store and modify values, and where to use them in code, with Kotlin-style declarations, constant and variable concepts, naming rules, and examples like lives.

Explore the eight primitive types, including six numeric types (bytes to longs), booleans, and characters; learn memory-driven choices, default values, and how floats and doubles compare.

Learn the string type as a flexible collection of characters, including zero-length strings, perform concatenation and interpolation, handle literals, length, substrings, replacement, and basic transformations to build dynamic text.

Explore ranges with the dot dot operator to declare sequences like 1 to 10, use the in operator for access and tests, reverse with down to, and step through ranges.

Explore nullable variables in Kotlin, declare nullable types with a question mark, and use safe calls and the Elvis operator to prevent null pointer exceptions.

Explore converting between variable types, from lower to higher order numbers, to booleans, characters, strings, and nullable versus non-nullable values, with practical guidance and pitfalls.

Master assignment, arithmetic, and unitary operators for variables, including =, +=, and %=, along with +, -, *, /, %, string concatenation, and not.

Learn how conditional and comparison operators compare values, test equality and membership, and drive control flow with booleans, if statements, and loops.

Explore how to create and populate a simple Kotlin array, using a string array for a character inventory, and access or replace elements with index or set, noting fixed size.

Explore the basics of if statements in control flow, testing conditions and using else if and else for multiple outcomes, with a game example moving a character by keystrokes.

Master advanced if statements, testing multiple conditions with and and or operators. Explore nested ifs and expressions in a game world with hit points, lives, and game over logic.

Explore when statements and when expressions, including ranges and is type checks, and see how they replace if and switch for clearer exhaustive logic.

Learn to check for null values using if statements and the Elvis operator to avoid null pointer exceptions, printing errors when needed, and handle nullable variables safely.

Master the while loop, a basic control flow structure that tests a condition at the start and repeats while true. Learn the do-while variant and guard against infinite loops.

Explore how continue and break statements control loops, enabling skip and exit behavior. See break labels for nested loops and examples that skip multiples of five or stop when found.

Explore how functions group code into reusable blocks, learn Cartland's unique function syntax, and cover parameters, return types, lambdas, inline generics, and recursive functions from a beginner perspective.

Explore basic function syntax in cotland and compare it to Java syntax. Learn how to create and call functions with and without parameters, and see how return types influence design.

Learn how return types turn functions into expressions, using a credits and purchases example to return boolean outcomes, handle early returns, and store results in variables.

Explore variable scope by comparing global, local, and parameter variables within a class and function. Learn when to use each to manage state and control access.

Explore variable scope in Kotlin: distinguish global, local, and parameter variables, how scope affects accessibility inside classes and functions, and when to prefer local over global variables.

Explore the fundamentals of classes and objects, constructors, properties, and methods, then master inheritance, interfaces, enumerations, and advanced class-like structures to build organized, object-oriented programs.

Learn basic class syntax, implement a simple class with and without a constructor, create new instances, and explore properties, fields, and behavior, plus interfaces, enumerations, and one class per file.

Use primary and secondary constructors to create a game character with a name or with a name and inventory, and employ init blocks to run code on instantiation.

Explore adding properties and behaviors to a game character by using fields, constructors, and simple methods to manage name, inventory, health, and access modifiers.

Explore the this keyword as a way to refer to the current class instance, resolving confusion between instance attributes and similarly named variables in code and methods.

Learn how visibility modifiers (private, protected, internal, and public) control access to variables, functions, and classes to enforce data encapsulation and preserve code integrity across packages and subclasses.

Learn how getters and setters control access to class properties, enforce value limits (health 0-100), and tailor access modifiers to allow reading publicly but writing privately or internally.

Learn how inheritance connects superclasses and subclasses, override methods and properties, and use the super keyword to extend behavior in object-oriented programming.

Explore interfaces as an abstract skeleton of methods and properties. Learn how a class can implement multiple interfaces while inheriting from a single superclass.

Set up es6 coding with Jaspan and its built-in linter, configuring jshint to catch errors, and practice extensively to solidify skills.

This beginner-friendly course covers JavaScript basics, callbacks, promises, and object-oriented programming, with ES6 features sprinkled throughout. Students code in Jaspan and learn to compile ES6 to ES5 with build tools.

Master JavaScript with practical starter tips, diverse resources like the Mozilla Developer Network, and habits like clear comments, naming consistency, short chunks, plain-language planning, rubber ducking, and hands-on practice.

Learn javascript basics, including variables, functions, if statements, and loops, then explore ES6 features like destructuring and template literals, plus dom manipulation.

Learn JavaScript types by exploring numbers and strings, arithmetic, and type conversions. Explore the Math object, random numbers and pi, and how parseInt and isNaN handle string to number conversion.

Explore booleans in JavaScript, showing how true and false control flow with console log and if statements, and examine truthy and falsy values, undefined, empty strings, zeros, and type checks.

Understand booleans and truth values, including truthy and falsy, arrays and boolean conversion in if statements. Distinguish undefined from uninitialized values and apply these concepts in web and Android development.

Explore object literals and the new object approach, learn key-value pairs, nesting, and access values with dot or bracket notation.

Explore how to keep object keys unique, map diverse value types, and use functions as methods within objects, then create reusable donuts with a constructor and new.

Explore arrays as data collections, using zero-based indexing and length, create arrays with literals or new array, and push, pop, and access nested items, including undefined entries.

Explore array methods to transform and rearrange data, including sort, reverse, and join. Learn to slice arrays to create subarrays, access last element by length minus one, and handle objects.

Explore how arrays store numbers and strings, and how objects use key-value pairs. See typeof checks, variable reassignment, and simple functions with console output.

Learn how to name variables in JavaScript by respecting reserved words, not starting with a number, using underscores, recognizing case sensitivity, and assigning values from other variables.

Explore how var is function-scoped and let is block-scoped in JavaScript ES6, and learn why accessing variables outside their scope can cause bugs.

Learn how let behaves more strictly than var and how to conditionally declare a let variable, assign it with an if statement, and log the result, highlighting block scope.

Explore let and konst (const) to understand block scoping, how constants cannot be reassigned, and how they can mutate internal array or object data without changing the binding.

Master the basics of let and const, understand block scoping, and choose const when value won't change, let for mutable values, and reserve var as a last resort.