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 Request: indicates 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 Patterns: reusable 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

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 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.

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"

Programming Language Constructs

/

There are hundreds of programming languages. Although most aren't commonly used, a software developer might use a number of them during their career. It's useful to understand the concepts that underlie these languages. Click here for a comparison of programming languages. 

Below are brief descriptions of some common and important programming constructs with links to more details.

Abstraction

Separating ideas from specific instances of those ideas. Click here for more details.

Access Modifier

Define characteristics of constructs such as classes and methods. Examples of modifiers are: public, private, package and protected:  Click here for more details.

Array

A data structure consisting of a collection of elements, each identified by at least one array index or key. Click here for more details.

Attribute

Defines a property of an object, element, or file. Click here for more details.

Block

Section of code grouped together. Click here for more information.

Branch

Sequence of statements triggered by a conditional. Click here for more information.

Callback

Pointer to a piece of executable code that is passed as an argument to other code, which is expected to call back (execute) the argument at some appropriate time. Click here for more details.

Class

Code template for creating objects. Think of architect's drawings. Click here for more details.

Conditional

Performs different actions depending on whether a condition is true or false. Click here for more details.

Constructor

In Object Oriented Programming, a block of code that's executed when an object is created. Click here for more details.

Container / Collection

An object made up of other objects. Click here for more details.

DOM (Document Object Module)

Convention for representation and interaction between objects in HTML documents. Click here for more details.

Dynamic Array

Variable sized data structure that allows adding and deleting elements. In Java, an ArrayList is one type of Dynamic Array. Click here for more information.

Encapsulation

Packing of data and functions into a single component. Click here for more details. 

Exception

Anomalous or failure event that may require special handling. Click here for more details. 

Expression

Combination of elements that produces a result. Click here for more details.

Garbage Collection

Reclaiming of unused memory. In some operating systems, such as Android, Garbage Collection is automatic. Click here for more details.

Hash

Used to provide direct access to data based on a calculated key. Click here for more details.

HTML (HyperText Markup Language)

A set of elements that can read by web browsers for displaying web pages. Click here for more details.

HTML Element

Individual component of an HTML document. Click here for more details.

HTTP Request

Indicates the desired action to be performed on an identified resource. Actions include: GET, POST, HEAD, OPTIONS, PUT, DELETE, TRACE, PATCH and CONNECT. Click here for more details.

Identifier

Names for objects and entities. Click here for more details.

Inheritance

Obtaining the capabilities on an object. Click here for more details.

Inner Class

A Class that is declared entirely within the body of another class or interface. An inner class cannot be instantiated without being bound to a top-level class. Click here for more details.

Instance

Specific realization of an object. Think of a house vs. the plans for a house. Click here for more details.

Iterator

An object that enables traversing a container, such as lists. Click here for more details.

JSON (JavaScript Object Notation)

Human-readable text used to transmit data objects consisting of attribute–value pairs. Often used to transmit data between a server and web application. Click here for more details.

Keyword

Word with a special meaning. Click here for more details.

List

A sequence of values, where the same value may occur more than once. Click here for more details.

Linked List

A data structure consisting of a group of nodes which together represent a sequence. Click here for more details.

Literal

Notation representing a fixed value. Click here for more details.

Loop

A sequence of statements which is specified once but can be carried out multiple times in succession. Click here for more details.

Metaclass

A class whose instances are classes. Click here for more details.

Method

Code that defines the run time behavior of objects. Click here for more details.

Mixin

A class which contains a combination of methods from other classes without using inheritance. Click here for more details. Not available in pure Java.

Object

In Object Oriented Programming, an object is an instance of a class. Click here for more details.

Operator

Perform actions on elements such as variables. Click here for more details.

Overloading

Ability to create multiple methods of the same name with different implementations. Click here for more details.

Overriding

In object oriented programming, is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes. Click here for more details.

Package

A Java package is a mechanism for organizing Java classes into namespace groups. Click here for more information.

Parameter

A reference or value passed to a function, procedure, subroutine, command, or program. Click here for more details.

Polymorphism

Provision of a single interface to entities of different types. Click here for more details.

Primitive

Smallest 'unit of processing' available to a programmer of a particular machine, or can be an atomic element of an expression in a language. Click here for more details. For example, in Java, primitive data types are: byte, short, int, long, float, double, boolean and char.

Reflection

Ability to modify an object's own properties at runtime. Click here for more details.

Regular Expression

Sequence of characters that can be used as a search pattern. Sometimes referred to as Regex or Regexen. Click here for more details.

Reserved Word

A word that cannot be used as an identifier, such as the name of a variable or function. Click here for more details.

Return

A value that is passed from a calculating function to an invoking function. Click here for more details.

Sort

Functions that put elements in a certain order. Sorting is used so often that many programming languages have built-in sort functions. Click here for more information.

Statement

Expresses some action to be carried out. Click here for more details.

Switch

Control mechanism used to allow the value of a variable or expression to change the control flow of program execution. Click here for more details.

Table

A collection of related data held in a structured format within a database. It consists of fields (columns), and rows. Click here for more details.

This

Refers to the object, class, or other entity that the currently running code is part of. Click here for more details.

Token

An object which represents the right to perform an operation. Click here for more details.

Type

Collection of rules for constructs such as variables and functions. Untyped languages allow any operation to be performed on any data type.  Click here for more details.

Variable

A storage location and associated name which contains a modifiable value. Click here for more details.

Java abstract Classes and Methods

/

The abstract modifier for classes and methods has to do with instantiation. Here's a summary:

abstract class

  • can't be instantiated
  • can be extended
  • must be declared abstract if it contains one or more abstract methods

abstract method

  • has only a declaration with no body, such as:
public abstract myMethod(String myString);

Java final, abstract and static Modifiers

/

The meaning of the final, abstract and static Java modifiers can be confusing and hard to remember. Here's a brief summary:

final

Generally means "can't be changed".

  • final class: can't be extended (sub-classed)
  • final method: can't be overridden or hidden by sub-classes
  • final variable: can only be initialized once 

abstract

Generally means "can't be instantiated".

  • abstract class: can't be instantiated, can be extended, must be declared abstract if it contains one or more abstract methods
  • abstract method: has only a declaration with no body
  • abstract variable: not allowed

static

Generally means "not associated with an instance".

  • static class: only nested inner classes can be static, they are not associated with any instance of the enclosing class
  • static method: doesn't use instance variables
  • static variable: is the same across all instances of it's containing class

additional notes

  • constants: use static final as variable modifiers
  • abstract static methods are not allowed