Posts Summary


Posts


Machine Learning and AI in 2030

Machine Learning and Artificial Intelligence are rapidly moving up a growth S curve similar to previous major information technologies. Twenty years ago,  the Internet/Mobil technology curve was in the same S curve position as ML/AI is today. The internet was growing in use, but nowhere near the penetration we see today. Mobil devices existed, but with small, black and white displays and no internet access ... primitive compared to today's large, touch screen, internet connected computers in your hand. ML/AI today is likely as primitive compared to what it will be in 2030 as the 1998 Internet/Mobil technology was compared to its present state. By one estimate, AI will add 16 trillion dollars to the world's economy by 2030. And the benefits of ML/AI discussed below with have a networked, multiplicative impact as they reinforce one another.

Developments and Benefits

It's impossible to predict exactly what ML/AI will look like over a decade from now, but it is possible to form a rough idea of what shape key developments will take. Here are a few...

Information Access

ML/AI is already used extensively for information search. Steady progress is being made in understanding the contextual nuances of search queries. This trend will continue, and by 2030 we should be able to find just the right information for almost any search with ever increasing precision.

Autonomous Vehicles

Autonomous vehicle progress has been steady and has achieved significant milestones. The technology has been demonstrated to work successfully at a fundamental level. There remain a number of barriers to widespread adoption. However, the benefits and incentives to overcome these barriers are significant. By 2030 we should see a significant number of autonomous vehicles on the road.

Healthcare

Many countries, including the United States, have aging populations. This will put an significant stress on healthcare over the coming decade. ML/AI holds the possibility of filling the gap between available resources and healthcare demand in 2030. According to one set of experts, we'll trust AI more than doctors to diagnose disease. This will free doctors to spends more time on the things technology can't yet do. 

Robotics and Automation

McKinsey predicts that by 2030, "60 percent of occupations have at least 30 percent of constituent work activities that could be automated." New jobs will also be created, but robotics and automation will continue to create significant shifts is how work is performed.

Education

ML/AI is disrupting the traditional model for successful education. A top futurist predicts the largest internet company of 2030 will be an online school and students will learn from robot teachers over the internet. ML/AI in education has the potential to create individually customized experiences that will enhance and speed the learning process.

Retail Shopping

Retail shopping is already being dramatically effected by ML/AI. The e-commerce share of total retail sales in the U.S. is rising rapidly. Customized on-line shopping experiences are growing in sophistication. Retail in 2030 may look very different than it does today and include  interactive dressing room mirrors and a more on-demand at-home shopping experience.

Professional Services

ML/AI can digest information at a speed and scope that already exceeds human capabilities. Professional service providers in 2030 will use ML/AI to provide analyzed and summarized information needed for decision making. This will dramatically speed services delivery and lower services costs.

Financial Services

Financial services rely on collecting, storing and analyzing vast amounts of data. ML/AI is already replacing workers who perform many of the tasks related to these activities. One estimate is that up to 230,000 employees in capital markets will be replaced by ML/AI as we approach 2030. This will lower costs and improve delivery of services, but will also require significant staffing shifts in the industry.

Agriculture

Advances in robotics and sensing technologies are radically modifying agricultural practices. New ML/AI approaches include: automated harvesting, pest control, animal tracking, and soil conservation. By 2030, we should see significant increases in crop yields at lowered costs.

Challenges

ML/AI does pose challenges as it progresses spreads further into our lives and businesses. Here are a couple of examples...

Changing Jobs and Learning New Skills

As mentioned above, McKinsey predicts that by 2030, "60 percent of occupations have at least 30 percent of constituent work activities that could be automated."  Overall, this would mean that about 20% of all jobs would be automated. New jobs will be created, with many of those requiring higher levels of education, training or skill. 

New Legal Frameworks

As more work is performed by ML/AI, legal questions of responsibility and liability will arise. One example is autonomous car liability. Autonomous vehicles are expected to lower deaths caused by accidents. The Atlantic reports that automated cars could save up to 30,000 lives per year in the United States. But how responsibility for the deaths that do occur remains an open question.

An Example Individual Scenario

It can be difficult to imagine a total picture of what ML/AI will mean for our lives in 2030. One way to grasp this is to imagine use cases that demonstrate their impact. Here's one example...

John is sitting in his study at home when he receives a notification on his smartphone. It tells him that the biosensor imbedded in his arm has detected a slight irregularity in his heartbeat. John hasn't noticed any physical pain or abnormality, but he clicks the notice and sees the display of a heart rhythm pattern with annotations showing him where there might be an issue. It assures him that it's nothing immediately life threatening, but that he should consult a doctor. He's shown the location of the nearest clinic and asked if he'd like an appointment be made along with arrangements for a ride. He clicks yes and immediately sees that his ride is on the way and will arrive in 5 minutes. John grabs his jacket and goes outside to wait for the car. In a few minutes, an autonomous vehicle pulls up, he gets in and a friendly voice asks him if he's John and going to the AbleWay clinic. John says yes, sits back and turns on his phone to read more information he's been sent about his symptoms. He arrives shortly at the clinic, is welcomed by name and escorted immediately into an examination room. A couple of minutes later, Dr. Able enters carrying a tablet which he uses to show John a real-time display of his heart rhythm. Dr. Able explains what could be the cause and that the condition is something they should watch carefully to see if it continues. He prescribes a medication that should help correct the arrhythmia and tells John that the medication will be delivered to his home by the end of the day. John shakes Dr. Able's hand and walks out to the reception desk where he's told that the clinic has his insurance information and the car to take him home is waiting outside. John enters the car and starts his trip home feeling relieved that he knows more about his condition and taking steps to deal with it. 

Using Stochastic Processes to Help Humanize Artificial Intelligence

In developing examples for my book on HTML5 Canvas (HTML5 Canvas for Dummies) I experimented with using stochastic processes to improve the realism of an animated displays. Early versions of the displays appeared rigid and artificial. Adding stochastic (random) variations brought the displays closer to real life and made them much more fun to watch.

Stochastic processes are already important to AI. Stochastic Gradient Descent combined with Backpropagation is used to iteratively modify data values passed between neural network nodes in order to minimize the error between the output of the neural network and the correct/true result.

Recently, I've explored whether stochastic techniques can be used to help humanize AI. Humans are not robots. We don't mindlessly pursue objectives without variation from a given path. A more human-like AI would certainly make the man-machine interface more pleasant to deal with than a purely robotic one. There are certainly AI applications where we don't want these kind of random variations taking place ... in autonomous vehicles for example. 

You can experiment with one of my displays that employs stochastic processes ... click here to see it in action - once it's started, click control to see the variables you can modify using your keyboard.

Machine Learning Mathematics

Machine Learning Mathematics

Mathematics is the study of topics such as quantity, structure, space and change. Mathematics provides a means to represent the real world in the form of numbers, relationships and equations.

Machine learning employs a wide variety of mathematical concepts and functions in order to create processes that:

  • analyze vast amounts of data in workable timeframes
  • discover actions, relationships and forces occurring in nature 
  • model the real world
  • interact with the real world

In short, mathematics is the base methodology employed to create machine learning modelsthat are used to address challenging applications such as image recognition, face recognition, natural language processing and pattern recognition: 

Mathematics -> Models -> Applications

Read More

Digital Computing + Machine Learning = A Perfect Match

Digital Computing has been with us for over 70 years. It's a deterministic technology using stored program software designed to produce accurate, precise results. For example, software for calculating your pay check will give you results that are correct down to the penny, just what you want!

Machine Learning technology is different ... it works in the domain of probabilities. For example, a machine learning based autonomous self-driving car makes many probability calculations every second ... such as the probability that a person approaching an intersection will stop and not cross in front of the car.

Digital Computing is able to perform some probabilistic calculations, but these are limited compared to those that can be performed by Machine Learning. Machine Learning is, conversely, limited in the deterministic calculations it can perform compared to the capabilities of Digital Computing.

So it's pretty obvious, the combination of Digital Computing and Machine Learning yields the perfect combination for interacting with the world we live in, as illustrated in the graphic below:

The combination of these two technologies will give us a huge boost in overall computing accuracy and cost effectiveness. Much of what we deal with on a daily basis is probabilistic in nature, and this dimension can now be effectively addressed with Machine Learning, such as is used in virtual assistants that are able to hear us speak, understand our words and give us answers to our questions.

And these two technologies will remain wedded to each other, as Machine Learning runs on a Digital Computing platform and needs Digital Computing to perform most practical tasks. Take our self-driving car example. That system needs access to precise road maps and feedback from car systems such as the engine and brakes. It's the combination of deterministic and probabilistic computing that creates the complete self-driving system that we'll end up trusting to get us safely home. 

The Rise of the Machine Learning and Artificial Intelligence S Curve

One of the hot technology topics of discussion lately surrounds the question of when the Machine Learning/Artificial Intelligence (ML/AI) 'singularity' will occur ... that is, when machine intelligence will evolve to equal human intelligence. Opinions run over a long time frame ... from as soon as 2029 (Ray Kurzweil) to around 2040-2050 (average of experts) to many decades from now.

Answering this question is linked to how rapidly one believes the ML/AI technology lifecycle S curve will rise. We do seem to have ML/AI S curve liftoff, as recent fundamental breakthrough developments in artificial neural networks, graphics processing units and other technologies have moved ML/AI from the laboratory to the field.

One perspective on the growth of ML/AI can be had by comparing ML/AI to the growth curves of previous major transformational information technology developments:

  • Mainframe & Centralized Computing
  • Personal & Distributed Computing
  • Internet & Mobile Computing

The chart below shows how the Machine Learning & Artificial Intelligence curve would look if it grew at the same rate as these previous developments:

The result is an S curve that grows at a rate that would place the singularity at the earlier of the estimates. These S curves seem to share some characteristics:

  • They're spread out by about 20 years.
  • The rapid rise of the S curve takes about 20 years.
  • At the early part of the curve, there's skepticism that the technology will achieve rapid growth. You can see a timeline of machine learning here.
  • At the top of the S curve, the technology is viewed as a must have for corporate survival.
  • As one S curve peaks, another begins its entry into the rapid rise phase.
  • Companies that are late in recognizing the emergence of a new major transformational technology often pay a high price. Major transformational technologies outperform predecessor technologies by orders of magnitude, making it difficult to impossible for companies that are late in adopting the new technology to compete with companies that are early adopters. 

Is it possible there's a hidden law of major transformational technology lifecycle growth? That is, once liftoff is achieved, do market forces pour into the technology and push it rapidly up the S curve over a period of two decades. Personally, I think this is likely the case, and that the ML/AI curve will be no different than its predecessors. Time will tell the tale. 

The Layers of Technology in Machine Learning and Artificial Intelligence

Machine Learning (ML) and Artificial Intelligence (AI) are changing the landscape of computing around the world, allowing us to do things with computers that were previously thought to be nearly impossible. ML/AI systems are now able to hear, speak, see, touch and interact with the environment and people around them.

In this article, I'll treat ML and AI together as a single topic. ML is the computer learning subset of AI, but for this discussion, they can be thought of as one.

A high level understanding of the layers of technology in ML/AI can help sort through the many options for developing and implementing an ML/AI system. ML/AI technology can be viewed as a three level hierarchy:

Mathematics > Models > Applications

Each of these layers provides an essential set of elements needed for a successful ML/AI system. Let's start with the mathematics base and build from there...

Mathematics

Mathematics, which dates back to 3000 BC and basic arithmetic, is a field of study that uses formulas (sequences of symbols) to represent ideas and the real world. Sounds a bit abstract, right? It is, but think about it ... ML/AI by its nature is doing just that inside a computing device - representing ideas and the real world. So mathematics is naturally and ideally suited to the pursuits of ML/AI.

ML/AI derives its tremendous power from the use of mathematics to, among other things, analyze probabilistic situations and outcomes. For example, an object recognition model might return the probability of .73 that a given photo contains the image of a cat. When we humans see a cat, we're usually pretty sure it's a cat. However, the combination of our senses and brains have done the complex mathematical-like analysis that produces that conclusion. Mathematics represents the calculations, estimations and processes needed to develop successful ML/AI models.

It's not necessary to understand all the math involved in an ML/AI system if you're using commercially supplied APIs or building on existing open source code. However, having some level of understanding of the underlying math can often be very useful and sometimes essential. One example, Stochastic Gradient Descent (SGD), is a mathematical function used to find a minima or maxima by iteration. It's used in a number of ML/AI models to iteratively improve the accuracy of output functions such as identifying objects in an input image. At a high level, the formula for SGD looks like this:

The components of this equation are:

  • Q( ): A function whose value is to be maximized or minimized
  • n: The number of times the function Q is recalculated
  • /: A division function used to find the average of the recalculated values of the Q function
  • i: A number indicating the individual version of the Q function 
  • w: A parameter that's used to find the minimal or maximal values for the function Q
  • summation: Adds up all the values of the individual Q function calculations and is represented by this symbol:
summation_symbol.png

Below is a list of some of typical mathematical concepts and functions used in ML/AI. Wikipedia is a good source of articles to start delving into these topics: 

Bayesian Probability and Statistics - Calculus - Classification - Cluster Analysis - Convolution - Deviation Analysis - Dimensional Analysis - Eigenvalues, Eigenvectors - Error Analysis, Accuracy, Precision, Sensitivity, Specificity - Functional Analysis, Activation Functions, Sigmoid Function, Rectified Linear Unit - Geometry, Geometric Transformations - Gradients, Stochastic Gradient Descent, Gradient Boosting - Graph Theory - Hyperparameter Optimization - Information Theory, Entropy, Cross Entropy - K-means Clustering - Linear Algebra - Logistic Regression - Loss/Cost Functions - Markov Chains - Mathematical Constants - Matrix Mathematics - Model Fitting, Underfitting, Overfitting, Regularization - Monte Carlo Algorithms - Pattern Recognition - Probability Theory - Regression Analysis, Linear, Non-Linear, Softmax - Sampling - Statistical Analysis, Bias, Correlation, Hypothesis Testing, Inference, Validation, Cross Validation - Time Series Analysis - Variation Analysis, Coefficient of Determination - Vector Spaces, Vector, Algebra, Scalars - Weights, Synaptic Weights

Models

Models are the embodiment in computer code of the mathematical representations used to perform ML/AI functions. In our example of a computer recognizing a cat in a photo, the ML/AI model represents the layers of processing needed to differentiate the image of a cat from all other possibilities.

Below is a conceptual model of an Artificial Neural Network (ANN), one of the types of ML/AI mathematical models. Data (shown as lines) is passed in a forward left to right direction between processing nodes (shown as circles). Numerical weights (w) are applied to individual data flows and biases (b) are applied to nodes in order to shape the output, such as the identification of a cat in an input image. Mathematical methods such as Stochastic Gradient Descent (discussed above) are used to adjust the weights and biases as data is repeatedly passed through the ANN.

In this diagram, the shapes and letters represent:

  • i: input layer node
  • h: hidden layer node
  • o: output layer node
  • w: weights applied to data going across layers
  • b: biases applied to node values

Below is a list of some of the mathematical models used in ML/AI. Wikipedia is a good source of basic information about these models:

Artificial Neural Networks - Association Rule Learning - Bayesian Networks - Decision Tree Learning - Deep Learning - Ensemble Learning - Hierarchical Clustering - Learning Classifier Systems - Learning to Rank - Long Short-Term Memory Neural Networks - Nearest Neighbors Algorithms - Recurrent Neural Networks - Reinforcement Learning - Sequence-to-Sequence Neural Networks - Similarity Learning - Sparse Dictionary Learning - Stochastic Neural Networks - Support Vector Machines - Unsupervised Learning

Applications

ML/AI applications use mathematical models, such as those discussed above, to perform meaningful tasks and produce meaningful results. Raw ML/AI results from mathematical models can be very interesting, but by themselves offer little utility. ML/AI applications provide that utility.

As an example, let's say we wanted to use our cat detecting Artificial Neural Network to let users of our smartphone app take a photo of a cat and determine what breed it belongs to. Our development team would need to:

  • Collect cat images from the internet
  • Sort the images into known breeds
  • Use the grouped images to train the ANN to recognize different breeds of cats
  • Test the trained ANN on images of cats of unknown breeds
  • Test the trained ANN on recognizing cats in images of many different types
  • Decide on the minimum acceptable probability from the ANN for determining a cat is really a member of the indicated breed
  • Maintain a table of the minimum acceptable probability for each breed of cat
  • Develop the user interface functions that allow the app user to photograph their cat and get the determination of which breed the application thinks it belongs to
  • Develop the server code to host the ANN and application software
  • Develop the Application Programming Interfaces (APIs) to connect client applications with the server code
  • Track ongoing performance results

ML/AI applications are appearing in every imaginable area of computing. If you do an internet search on almost any topic and include the term 'machine learning' you'll likely find results. Below are just a few examples of areas of active ML/AI applications:

Biometrics - DNA Classification - Computer Vision - Fraud Detection - Marketing - Medical Diagnosis - Economics - Natural Language Processing - Language Translation - Online Advertising - Search Engines - Handwriting Recognition - Speaker Recognition - Speech Recognition - Financial Market Analysis and Trading - Customer Service - Systems Monitoring - Recommender Systems - Self-driving Vehicles - Robotics - Cybersecurity - Legal Research - Criminal Investigations - Security Screening - Mapping - Healthcare - Face Detection and Recognition - Object Recognition - Weather Forecasting - Image Processing

Java vs. Python Programming Language Comparison

Java and Python are two popular programming languages that represent two very different approaches to structure and syntax. Java has a more formal, strict syntax. Python syntax is more forgiving and provides many shortcuts and abbreviations. Java is compiled and Python is interpreted.

The table below shows a sampling of Java and Python programming language elements that highlight these differences.

JavaPython
Block {
   . . .
}
def my_block( ):
      . . .
      CR
Class
Definition
public class Hello {
   . . .
}
class Hello:
      . . .
      CR
Class
Constructor
public Hello(Strng msg) {
    defaultMsg=msg;
}
def __init__(self, param1, param2, ...)
      self.p1=param1
      self.p2=param2
      CR
Class
Instantiation
Hello mHello=new Hello();
mHello=Hello( )
Class
Variable
static String myVariable; class MyClass:
      my_class_variable = 0
Comment // Comment text. # Comment text.
Constant final static MY_CONSTANT; MY_CONSTANT
Conditional if (a>b) {
   . . .
}  else {
   . . .
}
if (a>b):
      . . .
else:
      . . .
Exception
Handling
try { . . . }
catch { . . . }
try:
      . . .
except Error, e:
      . . .
Global
Variable
public class MyGlobals {
   public static String mG1
}
global my_global_variable
Importing import java.sql.*; import apackage as ap
from apackage import amodule
Inheritance class Child extends Parent{...} class Child(Parent):
Instance
Variable
// Declared outside methods
String mVariable;
class Hello:
      def __init__(self, param1)
            self.param1=param1
Iteration for (i=0; i<5; i++) {
    . . .
}

for (myElement : myCollection){
    . . .
}
for x in range(0, 5):
      . . .

for my_element in my_collection:
       . . .

for key, value in my_dictionary:
       . . .
Local
Variable
String myVariable; my_variable
Method
Definition
public void myIdea(String param) {
   . . .
}
def my_idea(my_parameter):
      . . .
      CR
Method
Use
myIdea(mParameter); my_idea(my_parameter)
Namespace
Reference
packageName;
my_namespace={'a':a_object, ...}
Null Value null
None
Statement
Separator
;
new line
Variable String mString="Hello Java";
my_string="Hello Python"

Software Components Overview

Below is a list of links to and brief descriptions of common software components. It's useful to keep these in mind and reference them during software design as a shorthand for code that will be written to implement the design. Implementing a component could involve just a few or many lines of code.

A suggested way to use these components in solving/coding a computing problem is to include them using a Separation of Concerns design pattern folded into what I call Layered Logic Problem Solving that includes these steps:

  1. Describe in words the problem to be solved. This might include references to software components listed below. You might also include solution acceptance criteria, possibly in the form of formal acceptance tests.
  2. Draw a block diagram of the main problem solution pieces. For more complex problems, other types of diagrams can be used.
  3. Annotate the block diagram with references to components such as those below.
  4. Code the solution in your chosen programming language.

Communications

  • Client-Server Architecture: components include:
  • HTTP Requestindicates the desired action to be performed on an identified resource - actions include: 
    • GET: retrieve data
    • HEAD: retrieve without response body
    • POST: create new subordinate data
    • OPTIONS: retrieve supported actions
    • PUT: create/replace data
    • DELETE: delete the resource
    • CONNECT: convert connection to TCP/IP tunnel, usually to facilitate HTTPS SSL
  • Internet Protocol Suite:
    • Layers: Application/Transport/Internet/Link
    • Levels: Send/Receive, Controls/Routing, Values/Translations
  • Firewall: monitor/control of incoming/outgoing traffic
  • JSON: JavaScript Object Notation, Human Readable, Attribute-Value Pairs, Java JsonObject
  • Load Balancer: distributes workload across computing resources
  • Message: data sent across processes
  • Network: allows computers to exchange data
  • Protocol: Data Formats, Address Formats, Address Mapping, Routing, Error Detection, Acknowledgements, Sequence Control, Flow Control
  • REST: Representational State Transfer, Stateless, Client-Server, JSON data
  • Socket: endpoint of a connection across a computer network

Data

Algorithms & Processes

Objects

  • Class: object template
  • Container: collection of other objects
  • Design Patterns: reusable solutions to common software problems  
  • Object Oriented Design Patternsreusable solutions to common object oriented software problems
  • Generics: specify type or method to operate on objects
  • Cloud Computing: internet based computing that provides shared processing resources
  • Interface : all abstract methods
  • Mutability: mutable, immutable, strong vs. weak
  • Objects: variables, data structure or function referenced by an identifier
  • OOD: uses inheritance, abstraction, polymorphism, encapsulation, other design patterns

Views

  • Ajax: groups of technologies for client-side asynchronous web applications
  • Android Fragments: UI segmenting, own lifecycle, FragmentManager
  • HTML5 Canvas:  bitmap, javascript
  • CSS:  describes the presentation of information
  • HTML:  head, body, div, script
  • Widget: simple, easy to use applicator
  • XML: markup language that defines a set of rules for encoding documents

Type System

A type system is a collection of rules that assign a property called type to constructs such as variables, functions, expressions and modules. Here are the two main dimensions of typing and some programming language examples:

Static vs. Dynamic

  • static:  type is set during compile
  • dynamic: type is set during execution

Strong vs. Weak

  • strong: type cannot change during execution
  • weak: type can change during execution

Language Examples

Java Data Structures

There are a number of commonly used Java data structures. Here are links to additional documentation and highlights of structural aspects: 

  • Array: fixed size, best for primitives 
  • List: fixed size, interface, ordered, allows duplicate
  • ArrayList: resizable , add to top, preferred unless need the capabilities of another structure
  • Vector: resizable, synchronized, add to top
  • Stack: LIFO, push/pop
  • Queue: FIFO, add to bottom/remove from top, interface
  • LinkedList: doubly-linked, push/pop, many other methods
  • Set: no duplicates, interface
  • HashMap: random access
  • TreeMap: sorted, efficient search
  • Binary Tree: each node has <=2 children
  • Binary Search Tree: sorted, fast lookup/add/remove
  • k-d Tree: k dimensional, space-partitioning, nearest neighbor search
  • Red-Black Tree: self-balancing, binary search tree, extra bit per node
  • Iterator: move forward and backward through data
  • Collections: perform operations on collections of data
  • Working with Java Lists: methods, iterators, collections
  • Data Structure Decisions: change, access, indexing, sizing
  • Common Java Array Manipulation Constructs: split, sort, binary search, iteration
  • Common Java ArrayList Manipulation Constructs: add, indexOf, remove, sort, binary search, interator
  • B-tree and Binary Search Tree Data Structures: like TreeMap
  • Sorting Algorithms: Collections sort, exchange, hybrid, insertion, merge
  • Big O Notation: O(1), O(log (n)), O(n), O(n log(n))
  • Update and Access Overview: The diagram below indicates how elements and values are updated and accessed. This is a broad overview of commonly used data structure classes, interfaces and objects ... please see the links above and below for more details. Some general observations are:
    • Arrays are different than the other structures in that they are accessed using bracketed index [n] references, such as myStringArray[3] instead of methods and can only contain primitives, not objects.
    • ArrayLists are generally preferred over Lists as they allow resizing. It's a very commonly used structure.
    • Vectors are much like ArrayLists with the additional characteristic that they are synchronized.
    • Queues and Stacks are specialized for LIFO and FIFO access.
    • LinkedLists are powerful structures that require more space for storage and time to execute some operations but are efficient for inserting and deleting objects in the existing order.
    • Sets are simple structures that don't allow duplicates.
    • HashMaps are commonly used when rapid, direct access to elements is the primary requirement.
    • TreeMaps are preferred when rapid search is the primary requirement.
    • Iterators and Collections operate on whole data structures.
    • ( ) empty parameter methods generally operate on the ends of a structure.
    • (element | object) only parameter methods generally operate on sets or the ends of structures.
    • (index | key) and (index | key, element | object) parameter methods generally operate on specific places within a structure.

Working with Java Lists

As shown in the diagram below, there are three major Java class groups used for working with lists: Lists (such as List, ArrayList, LinkedList, AbstractList, Stack and Vector), Iterators (Iterator and ListIterator) and Collections. Together, these classes and their methods provide a wide spectrum options for list construction, examination and manipulation. For an example of using these classes, look here.

Common Java ArrayList Manipulation Constructs

ArrayList data structures (also called Dynamic Arrays) are a frequently used programming function. ArrayLists have an advantage over arrays - ArrayLists are not fixed in size and can be dynamically changed by adding and deleting elements. Below are some common Java array manipulation constructs. For an overview of working with Java lists, look here.

Creating a new ArrayList

Creating a new ArrayList is coded as shown below using the String type with an initial capacity of 20 entries:

ArrayList mArrayList = new ArrayList<String>(int 20);

Constructing an ArrayList from an Existing List

The example below shows how to construct an ArrayList from the individual words in a String using an intermediary List object. Notice that the sequence of objects created is: String -> String array -> List -> ArrayList

String wordString = "this is a string of words";
String[] wordsArray = wordString.split(" ");
List<String> wordsList = Arrays.asList(wordsArray);
ArrayList wordsArrayList = new ArrayList<String>(wordsList);

add( )

The example below shows how to use the ArrayList add() method to add a String to wordsArrayList::

wordsArrayList.add("Example2");

indexOf( )

The example below shows how to use the indexOf() ArrayList method find the index of an entry:

int index = wordsArrayList.indexOf("Example2");

remove( )

The example below shows how to use the ArrayList remove() method using the entry index or the entry itself:

wordsArrayList.remove(index);
wordsArrayList.remove("Example2");

sort( )

The Collections sort() methods provide a variety of options for sorting ArrayList entries. Note that the ArrayList is sorted in place without returning a new ArrayList. This can be done because the array parameter is a value pointing to the ArrayList of objects. For example, the following statement would sort the words ArrayList from the example above using a modified MergeSort algorithm in an average O(n log(n)) time performance:

Collections.sort(wordsArrayList);

binarySearch( )

The Collections binarySearch() methods provide an efficient way to find an entry in a sorted ArrayList. For example, the following statement would find the index of the wordsArrayList entry for the String Example1 in an average of O(log(n)) time performance:

int entryIndex = Collections.binarySearch(wordsArrayList, "Example1");

iterator( )

The Iterator Class and ArrayList interator() method can be used to iterate over the entries of an ArrayList as shown in the example below :

Iterator mIterator = wordsArrayList.iterator();
while(mIterator.hasNext()){
System.out.println(mIterator.next());
};

Common Java Array Manipulation Constructs

Working with array data structures is one of the most frequently used programming functions. Arrays are implemented in a number of Java classes, such as String, Integer, and Boolean. Those arrays can be manipulated using the Java Arrays class (note that the Arrays class name is a plural). Below are some common Java array manipulation constructs.

split( )

The String split() method separates string characters into array entries using a supplied regular expression. For example, the following statement would create entries in the String array wordsArray using a blank character as a regular expression separator for processing the String wordString:

String wordString = "this is a string of words";
String[] wordsArray = wordString.split(" ");

sort( )

The Arrays sort() methods provide a variety of options for sorting array entries. Note that the array is sorted in place without returning a new array. This can be done because the array parameter is a value pointing to the array of objects. For example, the following statement would sort the words array from the split() example above using a Quicksort process in an average O(n log(n)) time performance:

Arrays.sort(wordsArray);

binarySearch( )

The Arrays binarySearch() methods provide an efficient way to find an entry in a sorted array. For example, the following statement would find the index of the array wordsArray entry for the String entryValue in an average of O(log(n)) time performance:

int entryIndex = Arrays.binarySearch(wordsArray, entryValue);

for( )

The for() construct can be used to iterate over the entries in an array. For example, the following statement would iterate over and print every entry in wordsArray:

for (String word : wordsArray) {System.out.print(word);}

If you want to know and use the index of each entry, then this construct can be used:

for (int i=0; i<wordsArray.length; i++) {System.out.print(wordsArray(i);}

Android Data View Adapters Overview

Android APIs provide classes and methods to facilitate displaying data in various forms, such as lists, arrays and custom layouts. The graphic below shows how the various classes and methods interact to produce the desired result.

Some examples of coding and use are:

Data

The data to be displayed can be in such forms as an Array, List, File or SQLite database. If a database is used, a Cursor object is also employed. A simple array of String values might be created and converted to an ArrayList like this:

String[] mStringArray = new String[] { "blue", "green", "yellow",
        "red", "orange", "black", "white", "purple"};
List<String> mList = Arrays.asList(mStringArray);
ArrayList<String> mArrayList = new ArrayList<String>(mList);

Cursor

Cursor is an interface that provides random read-write access to the result set returned by a database query. Setting up a Cursor for an SQLite database might look like this:

MySQLiteOpenHelper mDatabaseHelper = new MySQLiteOpenHelper(this);
Cursor mCursor = mDatabaseHelper.getDataIntoCursor();
ListView mListView = (ListView) findViewById(R.id.mListView);
MyCursorAdapter mCursorAdapter = new MyCursorAdapter(this, mCursor);
mListView.setAdapter(mCursorAdapter);

class MyCursorAdapter extends CursorAdapter {

    public MyCursorAdapter(Context context, Cursor c) {
        super(context, c);
    }
    // Implement CursorAdapter bindView method.
    public void bindView(View view, Context context, Cursor cursor) {
        String name = cursor.getString(1);
        TextView textView = (TextView) view;
        textView.setText(name);
    }
    // Implement CursorAdapter newView method.
    public View newView(Context context, 
                         Cursor cursor, ViewGroup parent) {
        TextView view = new TextView(context);
        return view;
    }
}
private final class MySQLiteOpenHelper extends SQLiteOpenHelper {

    private static final String DATABASE_NAME = "myDatabase";
    private static final int DATABASE_VERSION = 1;
    private static final String CREATE_TABLE_TIMELINE = 
        "CREATE TABLE IF NOT EXISTS table_name 
        (_id INTEGER PRIMARY KEY AUTOINCREMENT, name varchar);";

    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_TABLE_TIMELINE);
        db.execSQL("INSERT INTO ddd (name) VALUES ('Name1')");
        db.execSQL("INSERT INTO ddd (name) VALUES ('Name2')");
        db.execSQL("INSERT INTO ddd (name) VALUES ('Name3')");
    }
    @Override
    public void onUpgrade(SQLiteDatabase db, 
                          int oldVersion, int newVersion) {
    }
    public Cursor getDataIntoCursor() {
        String selectQuery = "SELECT  * FROM table_name;
        SQLiteDatabase db = this.getReadableDatabase();
        Cursor cursor = db.rawQuery(selectQuery, null);
        return cursor;
    }
}

Adapters

An Adapter acts as a bridge between an AdapterView and the underlying data for that view. A custom array adapter defined in Java might look like this:

class MyArrayAdapter extends ArrayAdapter<String> {
    HashMap<String, Integer> mHashMap = new HashMap<String, Integer>();
    public MyArrayAdapter(Context context, int textViewResourceId,
        List<String> objects) {
      super(context, textViewResourceId, objects);
      for (int i = 0; i < objects.size(); ++i) {
        mHashMap.put(objects.get(i), i);
      }
    }
    @Override
    public long getItemId(int position) {
      String item = getItem(position);
      return mHashMap.get(item);
    }
    @Override
    public boolean hasStableIds() {
      return true;
    }
 }

The custom array adapter mArrayAdapter would be instantiated and linked to a ListView mListView with Java code like this:

setContentView(R.layout.mLayout);
final ListView mListView = (ListView) findViewById(R.id.listview);
final MyArrayAdapter mArrayAdapter = new MyArrayAdapter(this,
        android.R.layout.simple_list_item_1, mArrayList);
    mListView.setAdapter(mArrayAdapter);

AdapterView

An AdapterView is a view whose children are determined by an Adapter. You might use an AdapterView like this:

private OnItemClickListener mMessageClickedHandler = 
  new OnItemClickListener() {
    public void onItemClick(AdapterView parent, 
                            View v, int position, long id) {
        // Do something in response to the click
    }
};
listView.setOnItemClickListener(mMessageClickedHandler);

View

View is the basic building block for user interface components. A view occupies a rectangular area on the screen and is responsible for drawing and event handling. A ListView contained in a layout might look like this:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/mLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
    <ListView
        android:id="@+id/mListView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >
    </ListView>
</LinearLayout>

ViewGroup

ViewGroup is a special view that can contain other views called children. A ViewGroup defined in XML might look like this:

<ViewGroup xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@id/mViewGroup"
    android:layout_height="wrap_content"
    android:layout_width="fill_parent" >
    <TextView
        android:id="@id/mTextView"
        android:layout_height="wrap_content"
        android:layout_width="fill_parent"
    </TextView>
</ViewGroup>

Layout

A layout defines the visual structure for a user interface. A layout might look like this:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/mLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
    <ListView
        android:id="@+id/mListView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >
    </ListView>
</LinearLayout>

Activity

An Activity provides a screen with which users can interact.

public class MyActivity extends Activity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    . . .
  }
}

Fragment

A Fragment represents a behavior or a portion of user interface an an Activity. Fragment code might look like this:

public class ArticleFragment extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, 
                             ViewGroup container,
        Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.article_view, 
                                container, false);
    }
}

Android Job Interview Topics

Because Android contains an extremely large number of Classes and Methods, it's impossible to hold all of the syntax and details in your head. For this reason, I've found that Android interview questions tend to be more conceptual in nature. For example, you might be asked how you'd approach a given problem using Android and Java constructs.

As you study the commonly used interview topics below, try to retain the main ideas and some relevant details. 

Android Fragments Overview

Android Fragments provide a mechanism to create modular sections of an Activity. You can see how Fragments fit into the overall Android structure in the blog post Android App Major Elements. You can see an example of Fragment use in the blog post Android Fragments.

Fragments provide a couple of significant benefits for Apps:

  • Fragments facilitate App adaptation to various screen sizes and dimensions. 
  • Fragments have their own life cycle that can be used to implement unique behavior for different App Fragments.

Below is an overview of Fragments and the Android elements they interact with for Fragment control.

Activity (Main)

The main Activity of an app uses the setContentView() method to establish a View.

Activity (for Fragment)

Activities can start and be started by Fragments.

View

The View class represents the basic building block for user interface components. A View occupies a rectangular area on the screen and is responsible for drawing and event handling. View is the base class for widgets, which are used to create interactive UI components (buttons, text fields, etc.). Views can be accessed via their ids or from the Root View.

Root View

The Root View is the base of the tree for all the Views for an app. It can be referenced using android.R.id.content.  

Layout (XML)

Layout XML can be used to define Views. When an app is compiled, the XML definitions are used to create View details. Note that this can include Fragment properties. If a Layout that includes a Fragment specification is used by the Activity setContentView() method, that Fragment will be automatically started by the Android operating system.

Fragment

A Fragment is a piece of an application's user interface or behavior that can be placed in an Activity. Sub classes of Fragment include: PreferenceFragment, DialogFragment and ListFragment.

Fragment Manager

The FragmentManager class is an Interface for interacting with Fragment objects.

Fragment Transaction

The FragmentTransaction class is used for performing Fragment operations.

Android App Major Elements

There are many elements that can be included in an Android app. It's helpful to see how these are clustered and interact, as shown in the chart below. Only major elements are shown. The Android Developers Website provides details on the full set of app elements.

The minimum required elements are shown with a red dot. An app with just these elements wouldn't be very useful, but you can see that there are many optional elements that can be added for a variety of functions. 

Intent Messaging

Intents are used to request an action from an app component. Intents are detected and acted upon by Broadcast Receivers.

Activities

Activities manage the Displays that app users see. Fragments are modular sections of an Activity that, among other uses, facilitate app adaptation to various screen sizes and dimensions.

User Interface

The User Interface includes a variety of pre-built elements that facilitate constructing screen displays, including: View, Control, Dialog, Notification, Setting, Action Bar, Menu and Toast.

Services

Services perform long-running operations in the background and do not provide a User Interface.

Asynchronous Operations

These elements facilitate asynchronous operations that protect the UI thread from undesirable delays. Loaders make it easy to asynchronously load data in an Activity or Fragment. AsyncTask allows performing background operations and publishing results on the UI thread without having to manipulate threads and/or handlers.

Data, Devices and Sensors

These elements facilitate the access to Data, Devices and Sensors. Connectivity provides access to devices and the Internet.  Content Providers can optionally be used to access databases and internal/external files. Sensors include: GPS, network location, accelerometer, gyroscope and more. 

Reference Elements

These elements are essential for app operation. Libraries provide access to compiled code from Google and other sources. Access to the user Display is built into the operating system. The Manifest include essential information about the app and its elements. Resources include: Layouts, Values and Drawables. Shared Preferences are use to store key-value pairs that act as global variables for the app.

Java vs. Ruby Programming Language Comparison

Java and Ruby are two popular programming languages that represent two very different approaches to structure and syntax. Java has a more formal, strict syntax. Ruby syntax is more forgiving and provides many shortcuts and abbreviations. Java is compiled and Ruby is interpreted.

The table below shows a sampling of Java and Ruby programming language elements that highlight these differences.

JavaRuby
Block {
   . . .
}
def/class/do/if...
   . . .
end
Class
Definition
public class Hello {
   . . .
}
class Hello
   . . .
end
Class
Constructor
public Hello(Strng msg) {
    defaultMsg=msg;
}
def initialize(msg)
   . . .
end
Class
Instantiation
Hello mHello=new Hello();
mHello=Hello.new("Hello Ruby")
Class
Variable
static String myVariable; @@myVariable
Comment // Comment text. # Comment text.
Constant final static MY_CONSTANT; MY_CONSTANT
Conditional if (a>b) {
   . . .
}  else {
   . . .
}
if a>b
   . . .
else
   . . .
end
Exception
Handling
try { . . . }
catch { . . . }
raise . . .
 
Global
Variable
public class MyGlobals {
   public static String mG1
}
$mG1
 
 
Importing import java.sql.*; require 'extensions'
Inheritance extends MyClass < MyClass
Instance
Variable
// Declared outside methods
String mVariable;
@mVariable
 
Iteration for (i=0; i<5; i++) {
    . . .
}

for (myElement : myCollection){
    . . .
}
5.times do | i |
   . . .
end
Local
Variable
String myVariable; my_variable
Method
Definition
public void myIdea(String param) {
   . . .
}
def myIdea(param="Starter")
   . . .
end
Method
Use
myIdea(mParameter) myIdea m_parameter
Namespace
Reference
packageName;
: :
Null Value null
nill
Statement
Separator
;
new line
Variable String mString="Hello Java";
mString="Hello Ruby"