Eric Schwabe

Experiments with WebGL

Mon, 02 May 2016 02:00:00 +0000

Coursera classes can be a great tool for learning new technologies or improving existing skills. Last year (Summer 2015), I took a course on WebGL to learn a bit more about web browser technology and refresh my knowledge of basic 3D rendering. The last time I worked with graphics APIs was a game development certificate course back in 2010 that used DirectX 9. I will discuss a bit about the assignments, the course content, and my overall impressions of the class.

The Results

Let’s start with the final product. Demos are always fun to show. :) The page renders a simple 3D scene with a grid and a set of objects (starting with a single sphere). The scene may be observed using the camera which starts out as automatically rotating around the grid. Additional objects may be added to the scene and their position, rotation, and scale controlled. Lastly, the environment has two simple spotlights whose position can be manipulated. Try it out!

WebGL Example

The class had us implement several intermediate steps before the final assignment. The other assignments provided opportunities to learn more about the computations involved with 3D graphics and the WebGL API. You can also try out those here.

WebGL Assignments

Assignment 1: Tessellation and Twist
Assignment 2: Painting with the Mouse
Assignment 3: Geometric CAD
Assignment 4: Adding Lighting
Assignment 5: Texture Mapping

The Content

The course itself covered the major topics required for 3D rendering and using WebGL. The class focuses on WebGL due to the fact that it is the primary platform independent implementation of a 3D graphics API. The high-level course outline is listed below. You can find out more on Coursera (course no longer offered).

Week 1: Introduction and Background
Week 2: WebGL
Week 3: The Open GL Shading Language and Interaction
Week 4: Displaying Geometry in WebGL
Week 5: Transformations
Week 6: Viewing in WebGL
Week 7: Lighting, Shading and Texture Mapping
Week 8: WebGL Texture Mapping
Week 9: Using the GPU
Week: 10: Render-to-Texture Applications

Course Review

Overall, I felt the class was a decent review of 3D graphics programming. The assignments and topics covered the most important aspects of using WebGL and turned out to be a great refresher for my knowledge. My main issue with the course would be the lectures. The audio and video quality was poor and the instructor did not explain topics thoroughly. I generally had to go back through the slides or lookup information through other sources to understand the topic. With that said, I would still recommend the course if you have an interest in WebGL.

I may expand on this post in the future to use as reference. Some of the intricacies of 3D programming (such as the model, view, and projection matrices) are easy to forget.

Interviews: Concepts

Mon, 18 Apr 2016 02:00:00 +0000

This series contains review materials for software engineer interview questions. This guide provides a high-level overview of common concepts in computer science.

Recursion

Overview:

An algorithm that calls itself within its definition.
- Recursive case a conditional statement that triggers the recursion.
- Base case a conditional statement that breaks the recursion.
Stack level too deep and stack overflow.
- Recursion places calls on the execution stack.
- Typically limited by the runtime or operating system.
- Must be aware of potential exploits (i.e. input data cannot be too large).
Often seen in algorithms such as depth-first search.

Dynamic Programming

Overview:

An algorithm that memoizes or caches intermediate results or return values from methods.
Problem must have two key attributes for dynamic programming to apply.
- Optimal substructure.
- Overlapping sub-problems.
Often seen in problems such as computing a fibonacci number.

Permutations

Overview:

A unique list of items where order matters
A given set of items has n! number of permutations.
If ordering a subset of the items, divide by the remaining permutations.
- P(n,k) = n! / (n - k)!
Typical implementation requires swapping each item into each position in the list.

Combinations

Overview:

A unique group of items where order does not matter
- e.g. Pick n items from a set
Computing the number of combinations starts with the number of permutations and divides by the number of redundancies.
- C(n,k) = n! / (n - k)! k!

Sets and Subsets

Overview:

A collection of distinct objects (elements or members of the set)
A set has 2^n subsets (including the empty set)
Subsets may be generated by starting with the empty set
Add elements to each previous subset to generate new subsets

Bit Manipulation

Overview:

Commonly used to optimize base 2 calculations.

Operations:

Name	C Language	Result
Negation	~	Invert all bits
And	&	True when both input bits true
Or	\|	True when either input bits are true
Exclusive Or	^	True when input bits differ
Left Shift	«	Shift bits left by specified amount and pad with zeroes
Right Shift	»	Shift bits right by specified amount and pad with zeroes

Facts and Tricks:

And	Or	Xor
x & 0s = 0	x \| 0s = x	x ^ 0s = x
x & 1s = x	x \| 1s = 1s	x ^ 1s = ~x
x & x = x	x \| x = x	x ^ x = 0

Powers Of 2:

2^N	Exact Value	Approx. Value	Human Readable
7	128
8	256
10	1024	1 thousand 1K
16	65536	64K
20	1048576	1 million	1MB
30	1073741824	1 billion	1GB
32	4294967296	1 trillion	4GB
40	1099511627776	1TB

Sources

Interviews: Algorithms

Mon, 04 Apr 2016 04:00:00 +0000

This series contains review materials for software engineer interview questions. This guide provides a high-level overview of basic algorithms including their implementations, applications and efficiency.

Depth-First Search

Overview:

Systematically search through a tree or graph, start at the root.
- E is number of edges.
- V is number of vertices.
Analyzes paths by searching depth of the tree or graph first (nodes farthest away).
Algorithm implemented using a stack (LIFO).
- Unvisited vertices added to stack.
- Visited vertices are marked to deal with cycles in graph (not required for a tree).
- Retrace steps when no unvisited options.
- Typically implemented using recursion.
Optimal for searching graphs and tress that are deeper than they are wide.

Applications:

Find all vertices connected to a given source vertex.
Find a path between two vertices.

Efficiency:

Search: O(|E| + |V|)

Breadth First Search

Overview:

Systematically search through a tree or graph, start at the root.
- E is number of edges.
- V is number of vertices.
Analyzes paths by searching closest nodes first.
Algorithm implemented using queue (FIFO).
- Put unvisited vertices in the queue.
- Repeat until queue is empty.
  - Remove vertex v from queue.
  - Add to queue all unmarked vertices adjacent to v and mark them as visited.
Examines vertices in increasing distance from root.
Optimal for searching graphs and trees that are wider than they are deep.

Applications:

Shortest path: Find path from s to t that uses fewest number of edges.

Efficiency:

Search: O(|E| + |V|)

Binary Search

Overview:

Search through an array to locate a specific element.
Algorithm typically implemented recursively.
- Compare element x to the midpoint of the sorted array.
- If x less than the midpoint, then search the left half of the array.
- If x greater than the midpoint, then search the right half of the array.
- Repeat the process treating the halves as subarrays until finding x or subarray is size 0.

Applications:

Find element in sorted array.

Efficiency:

Search: O(log N)

Quick Sort

Overview:

Comparison based sorting algorithm.
Algorithm typically implemented recursively.
- Shuffle the array (to ensure average element selected).
- Partition array so that for some element x (typically first element of subarray).
  - Entry a[x] is in place.
  - No larger entry to the left of x.
  - No smaller entry to the right of x.
- Sort each subarray.
- Requires special handling for duplicate keys, otherwise quadratic performance.
Quicksort is generally faster than mergesort.
In-place sorting algorithm (constant extra space).
Not a stable sorting algorithm (long range exchanges of elements).

Applications:

Sort an array of elements.
Java primitive type sorting uses quick sort.

Efficiency:

Best Case Sort: O(N log N)
Average Case Sort: O(N log N)
Worst Case Sort: O(N^2)

Merge Sort

Overview:

Comparison based sorting algorithm.
Algorithm typically implemented recursively.
- Divide array into two (recursively).
- Sort each subarray.
- Merge the two subarrays.
Merging algorithm.
- Create a temporary array that is the same size as the two halves.
- Keep track of three indices: output, first half, and second half.
Not an in-place sorting algorithm (linear extra space).
Stable sorting algorithm (maintains relative order of equal keys).

Applications:

Sort an array of elements.
Java generic object type sorting uses merge sort.

Efficiency:

Best Case Sort: O(N log N)
Average Case Sort: O(N log N)
Worst Case Sort: O(N log N)

Sources

Interviews: Data Structures

Sun, 27 Mar 2016 09:00:00 +0000

This series contains review materials for software engineer interview questions. This guide provides a high-level overview on basic data structures including their implementations, related algorithms, and efficiency.

Arrays/Strings

Overview:

Stores data elements based on an sequential, most commonly 0 based, index.
Based on tuples from set theory.

Types:

Optimal for indexing; bad at searching, inserting, and deleting (except at the end).
Linear arrays, or one dimensional arrays, are the most basic.
- Are static in size, meaning that they are declared with a fixed size.
Dynamic arrays are like one dimensional arrays, but have reserved space for additional elements.
- If a dynamic array is full, it copies it’s contents to a larger array.
Two dimensional arrays have x and y indices like a grid or nested arrays.

Efficiency:

Access: O(1)
Search: O(n)
Sorted Search: O(log n)
Insertion: O(1)
Deletion: O(n)

Stacks

Overview:

Collection of objects, typically supports push and pop operations
Examines the item most recently added, last in, first out (LIFO) data structures.

Types:

Commonly implemented with linked lists but can be made from arrays too.
Made with a linked list by having the head be the only place for insertion and removal.
Made with array by automatically resizing, repeated doubling

Efficiency:

Access: O(n)
Search: O(n)
Insertion: O(1)
Deletion: O(1)

Queue

Overview:

Collection of objects, typically supports enqueue and dequeue operations
Examines the oldest item, first in, first out (FIFO) data structures.

Types:

Commonly implemented with linked lists but can be made from arrays too.
Made with a linked list by having the head be the only place for insertion and tail the only place for removal.
Made with array by automatically resizing, repeated doubling
- Head and tail indexes are incremented and decremented modulo the capacity

Efficiency:

Access: O(n)
Search: O(n)
Insertion: O(1)
Deletion: O(1)

Hash Table

Overview:

Stores data with key value pairs.
Designed to optimize searching, insertion, and deletion.
Hash functions accept a key and return an output value unique to that specific key.
- Method for computing array index from key.
Hash collisions are when a hash function returns the same output for two distinct inputs.
- All hash functions have this problem.
- This is often accommodated by creating large hash tables (arrays).

Types:

There are a few different techniques for dealing with collision resolution.
Separate chaining
- Use array of linked lists. When searching for key, check each entry of list associated with hash value.
- Array size M must consider number of key-value pairs N. Typical choice M ~ N/5.
  - The constant is equal to average number of constant time operations.
Open addressing
- When a new key collides, find next empty slot, and store it there.
- Array size M must be larger than number of key-value pairs N. Typically N/M ~ 1/2.

Efficiency:

Search: O(1)
Insertion: O(1)
Deletion: O(1)

Linked List

Overview:

Stores data with nodes that point to other nodes.
- Nodes, at their most basic have one datum and one reference (another node).
- A linked list chains nodes together by pointing one node’s reference towards another node.
List requires maintaining a reference to the head and/or tail node.
Designed to optimize insertion and deletion, slow at indexing and searching.

Types:

Singly linked list has nodes that reference next node.
Doubly linked list has nodes that reference the previous and next nodes.
Circularly linked list is simple linked list whose tail, the last node, references the head, the first node.

Algorithms:

Runner
- Use two pointers to iterate through list.
- Increment at different rates to search for middle of list.
- P1 at 1x, P2 at 2x, P1 ends up in middle.

Efficiency:

Access: O(n)
Search: O(n)
Insertion: O(1)
Deletion: O(1)

Binary Tree

Overview:

Is a tree like data structure where every node has at most two children (left and right).
Designed to optimize searching and sorting.
They are comparably simple to implement than other data structures.

Types:

Balanced tree is a tree with minimum possible maximum height for all the leaf nodes.
- Red-Black and AVL Trees are common implementations of balanced trees.
Degenerate tree is an unbalanced tree, which if entirely one-sided is a essentially a linked list.
Complete tree is a tree with all levels filled except possibly the last and all nodes are as far left as possible.
Binary search tree is a tree that uses comparable keys to assign which direction a child is.
- Left children have keys smaller than the parent node.
- Right children have keys greater than the parent node.
- There can be no duplicate nodes.
- Because of the above it is more likely to be used as a data structure than a binary tree.

Algorithms:

Depth-First Search
- The search tree is deepened as much as possible on each child before going to the next sibling.
- Typically implemented recursively using the stack.
Depth-First Search Traversal Order
- Pre-Order: Root, Left, Right
- In-Order: Left, Root, Right
- Post-Order: Left, Right, Root
Breadth-First Search
- The search tree is broadened as much as possible on each depth before going to the next depth. (a.k.a level-order)

Efficiency:

Access: O(log n)
Search: O(log n)
Insertion: O(log n)
Deletion: O(log n)

Tries

Overview:

Variant of an n-ary tree in which characters are stored at each node.
Each path down the tree may represent a word (or at least a prefix to a word).
Useful for algorithms that do not require looking at entire key.
Performance based on height of trie, which is equal to maximum length of key/word (m).

Types:

R-Way Trie: Characters stored in each node with children up to the number of characters in the set.
Ternary Search Trie: Characters stored in each node with 3 children. Smaller (left), equal (middle), larger (right). More space efficient than R-way trie.

Algorithms:

Prefix match searches for all keys with a given prefix
Wildcard match searches each branch in node when wildcard specified for a character
Longest prefix searches for keys that match the longest prefix of a word

Efficiency:

Search: O(m)
Insertion: O(m)
Deletion: O(m)

Sources

Starting Something New

Sat, 05 Mar 2016 06:51:00 +0000

I figured it would be best to start the blog with a bit about myself.

Introduction

My name is Eric Schwabe. I work as a software engineer, currently in commericial aerospace test systems. I am always looking to expand my interests and expertise, so I decided to try writing a blog. I have always been fascinated with personal computers and electronic devices growing up. I grew up during the time when the Internet became common in every household.

Why A Blog

A blog seems like a useful place to keep track of my thoughts and things I’ve learned. Information tends to be difficult to organize, so creating my own personal reference guide should be useful. Google and other companies do a decent job :), but it’s certainly not a collection of only my interests or recent work. It’s easy to lose track of your own “progress” over time, so I hope this will be a useful source to reflect upon in the future.

The difficult part about starting some new is committing to the time investment. Writing blog posts certaining takes time and expect it will be a bit of hurdle to actually sit down occassionaly and write down my recent experiences. For now, I plan on adding posts for significant accomplishments or useful tidbits, but I may commit to a more regular schedule in the future.

Sources

As for topics, I plan on primarily focusing on areas related to software engineering, programming, and technology. Like most professional software engineerings, I have a few news sources that I tend to read often and expect that I will post my own thoughts on the issues at times.

Here are a few of my current news sources: