Create Multiple Finance Apps with Android and Blockchain!

Explore the basics of blockchains, including what they are, how they are structured, and how they work. Understand decentralization, block structure, and mining, and see how blockchains underpin decentralized apps.

Explore what blockchain is as a decentralized digital ledger of transactions, organized into blocks on the Ethereum blockchain, using cryptography to secure and verify immutable records.

Explore decentralization in blockchain networks, where many users and miners run a peer-to-peer system with no single point of failure and instant, verifiable transactions.

Understand how a blockchain forms a linked list of blocks, each containing transactions in a Merkle tree and a header that links to the previous block, secured by mining.

Miners compile transactions into a block, solve a hash puzzle, and add the block to the chain to execute transactions and earn rewards, including gas and ether.

Explore blockchain basics as a digital ledger governed by decentralization and an open peer-to-peer network. Learn how blocks, mining, and forks secure transactions with hashing, nonces, and tamper-proof ledgers.

Delve into how decentralized apps work on the blockchain, compare them with regular web apps, and examine smart contracts and the role of solidity in this foundational theory.

Explore how the Ethereum blockchain powers decentralized apps with ether as the reward currency, faster transactions, and gas fees based on computation, unlike Bitcoin.

Decentralized apps run on a blockchain rather than a single server, eliminating single points of failure. Oracles provide external data, and gas fees govern transactions.

Learn how decentralized apps run on a block chain, with data fetched from the chain and transactions that add or update values, guided by smart contracts and gas costs.

Explore how smart contracts automate secure, tamper-proof transactions on the blockchain, with gas considerations and Solidity coding basics.

Recap the core ideas of blockchain theory, decentralized apps, how DApps run, and smart contracts, while highlighting oracles, gas, and solidity as the building blocks for future tutorials.

Explore solidity language basics, covering five topics—common types, functions, structs, and creating contracts with their components—alongside browser-based remakes and essential imports and comments.

Explore Solidity boolean types as the simplest common type, including true/false values, default false, and boolean operations like and, or, not, with global vs local variables in Solidity.

Explore signed and unsigned integers, basic arithmetic and assignment operators, and type conversion in Solidity, using a transaction balance example and notes on bit widths and gas.

Discover strings in Solidity, which are simple and stored as byte arrays. Learn how to declare an empty string, assign a name, and obtain length via bytes(name).

Explore addresses as a common type in blockchain programming, including 20-byte hex addresses, balance querying, and transferring ether with sender address handling via message.sender.

Explore one- and two-dimensional arrays in Solidity, including storage versus memory arrays. Learn to access and modify elements by index and grasp multi-dimensional arrays with balances and transactions.

Master solidity array operations by using get, set, push, and delete on storage arrays and learn how memory arrays differ, including length handling and the limits of push and delete.

Explore storage vs memory in solidity and distinguish value vs reference types. Learn how arrays behave, gas costs, and how memory and storage pointers affect state and local data.

Explore Solidity function syntax, define and call functions with parameters and return values, and use constructors and events to instantiate contracts and log data during deployment.

Learn how Solidity functions use parameters to input values and return results. Explore single and multiple returns, memory versus storage, and named versus implied return syntax.

Explore solidity function semantics by examining visibility modifiers (external, public, internal, private), view and pure restrictions, payable functions, and fallbacks, plus modifiers and inheritance implications.

Learn how to implement if statements, else if branches, and nested tests in Solidity to verify balances against transactions, handle messages with events, and prepare for while and for loops.

Learn how while loops control flow in Solidity, from syntax and iteration to break, continue, and return for safe exits and avoiding infinite loops.

Master for loops in Solidity by comparing them to while loops, learning start, end, and increment, and iterating through arrays to total transactions.

Explore Solidity structs to model a user with first name, last name, balance, and a transactions array, and learn storage versus memory instantiation.

Explore Solidity mappings as key-value stores, including int-to-string and string-to-int examples, and see how mappings pair with structs and an id list to organize data.

Learn how a contract transaction uses the message data: retrieve the sender address, read the value and gas, and see how mappings relate to user data in Solidity.

Discover how enumerations define a days-of-the-week type with seven fixed values, restricting variables to valid options and preventing typos.

Explore contracts in Solidity by building a contact list: define structs, constructors, and state variables, and implement add and get functions with string handling and owner.

Learn to instantiate contracts, deploy new instances, and access or modify state with public getters and setters. Understand public vs private access and how memory and constructor shape contract state.

Explains inheritance in Solidity, showing how a subclass inherits state and functions from a super contract, uses constructor forwarding, and overrides behavior with the super keyword to extend functionality.

Master solidity basics by studying variables, arrays, functions, control flow, structs, and contracts, plus memory vs storage and inheritance to build decentralized apps.

Create a decentralized voting app on a block chain with one vote per user for two options, and an administrator who ends the poll and shows results using smart contracts.

Design a simple voting smart contract skeleton in solidity, with candidate and voter structs, mappings, and functions to cast votes for Pepsi or Coke and display results.

Implement a smart contract with a chairperson to manage voting, cast votes, track Coke and Pepsi, determine a winner by a for loop, and end voting as the contract dictates.

Build and style the app interface using HTML, CSS, and JavaScript to create Coke vs Pepsi voting page with a vote table and winner display, preparing for smart contracts integration.

Learn to style a decentralized app interface with css, covering spacing, centering, table borders, and responsive width. Prepare JavaScript to toggle visibility and connect to the smart contract.

Configure a JavaScript interface for the decentralized app by assigning IDs, accessing elements with getElementById, tallying Coke and Pepsi votes, showing totals, and announcing the winner.

Install test rpc to simulate a smart contract on the blockchain, then set up npm, web3, and a new project to connect the contract to the interface.

Connect your app interface to a deployed smart contract on a local host using Web3, wire the contract ABI, and access contract methods and variables in the browser.

Learn how to replace JavaScript voting logic with smart contract functions, implement cast vote checks, update candidate votes, and display Coke, Pepsi, and total votes in a decentralized app.

Learn to replace JavaScript get winner logic with a smart contract function, determine the winner by candidate votes, and convert the bytes32 result to a readable string for display.

Update the get winner function to require the chairperson, add a tie case, and enforce security checks before announcing the winner.

Learn to build a simple decentralized voting app on a blockchain using Solidity contracts and a JavaScript interface, tested locally with a blockchain simulation.

Explore blockchain fundamentals, decentralized apps, and Solidity language basics, and learn to build, test on a simulated blockchain, and deploy a voting dapp with a JavaScript interface for beginners.

Launch a new android project, name it meaningfully, configure the package name and sdk settings, and explore the main activity and its activity_main layout using graphical and text views.

Explore different android layouts, focus on the table layout to present information quickly, and learn how XML markup shapes the app’s foundation with TextView and back-end structure.

Explore item properties in Android layout design, adjust text views and buttons, set IDs, margins, and dp values, and compare graphic layout with XML layout to streamline app design.

Explore how Android projects organize files into folders and backend code to run apps, while noting you don't need every line and may update libraries to ship quickly.

Explore portrait versus landscape orientation in Android apps, switchable layouts, and theme and translation options, prioritizing portrait for quick user access via the main activity.

Change the object view with the palette, choosing previews from small to icon and text, drag items like checkboxes or image views, and undo with control or command z.

Set up and run the Android emulator to test your app early and often. Build and test every three to five minutes to catch issues before they compound.

Center the text in the text view by adjusting gravity and setting the text size to 30, then observe how the default setting and graphic layout affect the calculate button.

Hook up the activity main file by importing android widget classes, declaring a text view and a calculate button, and wiring them to update text via code.

Connect text views and a button by their IDs TextView1, TextView2, and Button1 in the onCreate method using findViewById to enable dynamic user interface updates.

Learn how to change the text in a text box by using set text, declaring variables, importing widgets, and running the app in the emulator to see the update.

Learn to add an on click listener to an Android button so clicks update the text and execute a defined command.

Explore using integers in Java to update scores and handle numeric input. Learn about integer variables, adding numbers, and the difference between numbers and characters.

Add an edit text to capture user input in an Android app by importing android.widget.EditText, naming it user input, and initializing with zero to prevent nulls and enable numeric operations.

Bind the edit text by id, read the user input with getText, convert it to a string and assign it to a number variable, then print the value on screen.

Test the app by entering values, convert negative totals to positive by multiplying by -1, and validate the math with large numbers to ensure the tutorial functions.

Explore number variables in this course, learning how integers, floats (with the f suffix), longs, and doubles store data as typed boxes and why type matching matters.

Declare and use string variables with quotes, print results, and substitute values in code. Compare string and char variables, noting quotes and practical uses.

Learn to name variables clearly and implement an if statement that checks if the input equals 100, then display the 'you have a hundred dollars in your bank' message.

Learn how to use multiple if statements, initialize variables, and apply comparison operators to handle amounts in Java, printing messages for less than, exactly, or more than one hundred dollars.

Add variables to the project to display numeric input alongside text, format with spaces and a dollar sign, and preview results in the emulator.

Identify and fix a common mistake when developing Android apps by using the correct input variable, ensuring the app processes usable data instead of raw edit text.

Learn how to use else if and else with if statements to handle multiple conditions, including a final else as a failsafe when none of the conditions are true.

Learn to add a string variable in Android by using plain text input, retrieving text from an edit text, and concatenating it with numbers to display a formatted message.

Replace the enter name text with a hint in the input, so typing uses the hint without becoming a string; when cleared, it shows nothing in the field.

Add a clear button to reset the app, wire a second button with a click listener, and update the display text back to total money using setText.

Import the Android input method manager and obtain it via getSystemService to dismiss the keyboard with hideSoftInputFromWindow using the window token and zero flags.

Refactor by creating private void methods to reuse code, call them from multiple places, and improve readability and maintainability of your app's logic.

Change a text color using rgb values in code, adjusting red, green, and blue from 0 to 255. Reset to black when cleared and explore color dot rgb values.

Explore ways to change color in code, including color dot green, rgb colors for non-standard hues, and web colors with hex codes like ff0000.

Learn how to safely delete objects in apps, including multi-step steps to remove layouts, private methods, and references, while using prototypes and quick resets to avoid crashes.

Master Android table layouts by building table rows, placing text, buttons, and radio buttons, adjusting gravity to center content for a clean, minimalist mobile interface.

Distribute weights evenly to fit and align interface elements, using the distribute weights evenly command after adjusting buttons. Remove extraneous table rows by right-clicking and deleting to streamline the design.

Adjust dp-based margins to create comfortable padding around user interface elements, including buttons and table rows. Understand how margins impact touch accuracy across Android devices and screen sizes.

Set the Android screen orientation to portrait for usability, with an option to switch to landscape; portrait favors efficiency, while landscape suits games for kids and video viewing.

Explore vertical linear layout in android, learn how to stack views on new lines, add text, a table row, and multiple buttons, and use the outline to review layout structure.

Explore how horizontal layouts compare with linear layouts, noting that horizontal versions often limit adding items below, and how landscape mode changes their usefulness for app design.

learn to implement a grid layout in android, set column and row counts, and compare it to a simple table layout for older devices.

Create a simple Android tip calculator by starting a new Android project, configuring min sdk and target, and building a vertical layout with a table layout for clarity.

Add text fields and numeric inputs for meal cost and tip percent, using decimal and currency formats, while following a three-part workflow: set up, program, and design.

Import android.widget components, declare edit text fields for tip percentage and total cost, and set up calculate and clear buttons in the activity main file.

Declare and label Android UI components: two edit texts for tip percentage and meal cost, two text views for totals, and two buttons for calculate and clear.

Connect the visual user input with backend code by wiring edit text fields in onCreate, capturing tip percentage and meal cost from the user.

Set up button interactions in an Android app by adding on click listeners for calculate and clear actions, and manage braces, semicolons, and comments for runnable code.

Define private void methods like calculate and clear app to respond to button clicks, and use calculate tip to avoid conflicts with reserved words.

Declare local variables within private voids and manage scope inside curly brackets; use doubles for tip percentage and meal cost, then convert results to strings for display.

Explore converting percent values to decimals for accurate tip calculations in finance app code. Learn to manage raw data and derived variables, and apply a clear workflow for percent math.

Define variables for meal cost, tip percentage, and total tip, then compute the total tip as meal cost times the tip percentage and derive the total meal cost.

Print the calculated values to the screen by setting the text of text views, appending total tip and total meal cost with a dollar sign.

Add and map additional objects in the code by linking buttons and text views with their IDs using findViewById, ensuring correct dot IDs and saving the changes.

Run the Android app in the emulator to test functionality and verify meal cost and tip calculations. Note the simulator differs from a real device; rounding to two decimals applies.

Round totals to two decimals using string.format with %1.2f and define round total tip and round total meal cost to format the values.

Learn how to dismiss the Android keyboard by implementing an input method manager, using getSystemService with InputMethodService, and calling hideSoftInputFromWindow when pressing calculate or clear.

Explore how to implement a clear button to reset input fields in an Android app, including clearing text fields, managing hints, and updating total tip and total meal cost displays.

Conclude the course by reviewing a tip calculator app, exploring landscape design and keyboard space. Next, apply learned concepts and innovate the app in the next class.

Explore how calculators reveal core app processing, from tip and distance calculations to data input driving results, and start a basic Android project using a table layout and xml.

Design a calculator interface by arranging text fields and a table row of operation buttons, supporting decimal input and centered layout to prototype a simple finance app feature.

Learn to rename and organize edit text IDs for consistency, using edt prefixes, and standardize button labels such as calculate, clear, plus, minus, multiply, and division.

Import Android widgets like EditText, TextView, and Button into the main activity file, declare IDs such as edtFirstNumber, edtSecondNumber, and txtAnswer, and wire up the corresponding UI elements.

Learn to locate specific UI objects in an Android app by id, wire edit texts, text views, and buttons, and set original price, selling price, tax percentages, and total profit.

Double check your user interface by verifying button ids, text outputs, and calculations. Read every line and avoid copying errors to ensure the app behaves correctly.

Identify and fix common import errors in Android development by removing unnecessary imports, then test in the simulator to improve load times and plan to add functionality and a tutorial.

Set up province-based tax logic by reading the selected item from a spinner and applying if statements for each province's tax amount.

Change the color of the buttons in an Android app by handling on-click events to set background and text colors, and test changes in the simulator.

Implement a one-active-button logic by using boolean variables for each button, setting one to true while others remain false, with if statements updating colors and state.

Add the calculate button logic by creating a private void calculate logic, invoked on click, using boolean flags to track the pressed button and if statements for all buttons.

Master variable scope inside curly brackets, declaring variables outside blocks for reuse, then read text fields, parse numbers to doubles, and compute results in conditional statements.

Add basic arithmetic logic to your app by implementing addition, multiplication, subtraction, and division; enter first and second numbers, press calculate, and display the result.

Demonstrate printing the calculation result to the screen by converting a double to a string with valueOf and displaying it via textAnswer.setText, then test arithmetic operations.

Implement the clear button by creating a clear logic method that empties input fields, resets hints, updates the answer, and returns all buttons to gray while also resetting backend booleans.

Validate edit texts in an Android app by checking for empty inputs, retrieving text, trimming, and converting to numbers. Use if/else logic to cover cases and display please enter numbers.

Add a boolean failsafe called error answer and wrap the answer display in an if statement to show the result only when there is no error.

Review how the code's complexity dissolves into simple styling of text and button colors in an innovative calculator. Apply these concepts to build or modify your own calculator.

Learn to build a simple savings calculator that visualizes how much you can save, using a table layout for an easy, cross-platform Android, iPhone, and Windows phone tutorial.

Design a savings calculator by adding decimal inputs and salary fields for monthly, weekly, and hourly income, plus yearly, 10 year, and 25 year savings projections.

Rename android ui text fields for income and savings to clear, readable ids, reducing human errors and improving readability in java-based apps, with calculate and clear actions.

Import Android widgets, declare edit texts and text views for salary and savings across monthly, yearly, 10 years, and 25 years, and configure calculate and clear buttons, plus productivity hack.

Bind edit text fields by id in onCreate for salary, weekly and monthly savings, weekly and hourly income, and yearly savings using find view by id and r.id.

Add and wire buttons in an Android app by finding views by id, wiring B10 calculate and B10 clear, and setting on click listeners to run the corresponding highlighted areas.

Organize your code by adding private void methods for calculate logic and clear logic, and call them from the calculate and clear actions to simplify the app.

Connect the calculate button to a private void called math calculation, moving all math logic into that method and setting up variables for clear logic.

Declare doubles for salary and weekly savings, parse user input, tax and convert to string, and perform on-the-fly math to calculate monthly, yearly, and hourly figures.

Teach how to compute salary and savings variables by converting monthly, weekly, and hourly wages, using a 40-hour week, and project savings for 10 and 25 years.

Learn to print all this to the screen, including monthly income, weekly income, hourly income, and savings values, using copy-paste for speed while ensuring consistent labels and spacing.

Spot and fix common mistakes by using the correct on click listener instead of long click, and periodically review your code to catch autocomplete errors.

Run the Android app to test input, observe keyboard hiding and decimal formatting issues, and note fixes. Android expands text to fit the box, unlike stricter bounds in other environments.

Hide the keyboard in Android apps by obtaining the input method manager, invoking hide soft input from window with the correct window token, and testing in the emulator.

Round numbers to two decimal places by formatting strings with string.format, and apply it to salary monthly.

Add a clear button by implementing private clear app logic to reset inputs, apply colon spacing and a dollar sign, and dismiss the keyboard.

Enter a salary and calculate monthly, yearly, and 10-year savings, showing how weekly amounts like 111 dollars or 300 dollars accumulate into larger totals.

Add input validation logic for salary and weekly savings by converting text to strings, trimming, and using if statements to handle empty fields and default to zero doubles.

Push calculate and clear to see a finance app compute salary, weekly savings per week per hour, and monthly to twenty-five year projections, illustrating the power of action.