Kimberly Moffitt, an assistant professor of American studies, participated in a panel discussion on The Marc Steiner Show on April 10 that focused on what the true meaning of “happiness” is in the context of WEAA’s Happiness Spring Membership Drive.

The panelists discussed the pursuit of happiness and what it meant to the founders of the United States, what it means to Americans today and how it’s possible to create a world where everyone has the right to happiness. During the program, Moffitt weighed in on her view of the definition of happiness.

“I think it does mean freedom, and I think that’s what our founders wanted it to mean. I think where we are now is that we see freedom in very different ways,” Moffitt said.

“In some respects I think we’ve moved away from what the original founders wanted to see in terms of this idea of freedom. At the same time of encouraging freedom, we’ve created so many social hierarchies that make it difficult to actually have the freedom to do much of what we’d like to do,” she added.

Other panelists in the discussion included Jeff Singer, Founder and former Executive Director of Health Care for the Homeless and instructor at the University of Maryland School of Social Work and Alex Boston, former director of Homeless Services in Baltimore City and Country Director for the Peace Corps in Kyrgyzstan and Jordan. To listen to the full segment on The Marc Steiner Show, click here.

As part of Environment Month at Writer’s Voice, a national radio show and podcast featuring author interviews, readings, and reviews, Public Policy Professor John Rennie Short was interviewed about his recent book, Stress Testing the USA (Palgrave MacMillan). In his book, Short applies the stress test concept to four major events the United States experienced at the start of the 21st century: the invasion of Iraq, the financial meltdown, Hurricane Katrina and the BP oil spill.

“These four major events are the equivalent of an incredible cardiovascular workout for the United States where you saw things that didn’t work so well. When everything is going along well, there is economic growth, and things are progressing and everyone is happy, the system is self-justified,” Short said.

“But when things go wrong, that’s when it reveals things that often we don’t want to discuss or are hidden below the surface,” he added.

To listen to the full interview on Writer’s Voice, click here. The interview was scheduled to air on Writer’s Voice broadcast stations across the country throughout the week of April 7.

Language, Literacy and Culture doctoral student Kevin A. Wisniewski was recently named a 2014 Michael Denker Chesapeake Chapter Fellow at the American Printing History Association. The fellowship is named after a former Chesapeake Chapter president, and it offers a one-year membership and active participation in the association’s various activities throughout the Mid-Atlantic region, including a presentation of original research at an upcoming symposium on the history of colonial printing and typography.

Wisniewski will also be presenting a paper at the upcoming American Literature Association’s annual meeting in Washington, D.C. with professors from Ohio University, the College of William and Mary and the University of Massachusetts from May 22-25 in a panel entitled, “Graphic Humor in the 19th-Century Periodical.”

Finally, Wisniewski’s review of Michael David Cohen’s monograph Reconstructing the Campus: Higher Education and the American Civil War (University of Virginia Press, 2012) is forthcoming in the journal Civil War History, and he is awaiting the publication of sections he completed on the early American republic for a forthcoming online, Open Access American History textbook entitled American Yawp. 

The project is edited by Joseph Locke (University of Texas-Pan American) and Ben Wright (Rice University) and boasts an impressive editorial board that includes Edward Ayers, Kathleen Brown, Joyce Chaplin, Woody Holton, James Merrell and Richard White.

Honors College Professor Ellen Handler Spitz recently traveled to Sewanee, Tennessee to the University of the South, where she was invited as a guest lecturer in the pioneering program, “Child, Family and Community Development in Rural Appalachia.”

The program is sponsored by the University of the South, The Yale Child Study Center and Scholastic. A major goal of the program is to help children and families in poverty-stricken Appalachia while building community and fostering a rich cultural life.

As part of the program, Spitz lectured and read story books to four groups of children ranging from three to six years old and met with colleagues and planners, sitting in on a variety of sessions and classes that involve the program, the arts, children’s literature and psychology.

Once a month, we’ll profile one of the amazing Phonathon students working in UMBC’s call center. This week, say hello to student caller Regine, class of 2014.

Regine will be graduating in December of this year and has worked as a Student Caller and Supervisor for Phonathon since September 2011. Regine is originally from Haiti and is finishing her degree in Health Administration and Policy. We sat down with Regine to get to know her a little better and here’s what we learned:

Q: Why did you choose to come to UMBC? What do you enjoy most now that you’re here?

A: I chose to come to UMBC because I heard it was a good school for science and I was interested in Biology and public health. Now, I enjoy meeting new people every day from all over the world.

Q: What activities do you enjoy outside of class?

A: Getting my homework done on time. I really enjoy sitting and reading in the quad when it’s nice out.

Q: What do you like best about being a student caller?

A: Talking to alumni and learning about their experience. They always have the best stories and jokes about the campus.

Q: What are your plans after graduation?

A: Go to grad school to study clinical epidemiology and global health!

I assume you are a computer programmer. Perhaps you are a new student of computer science or maybe you are an experienced software engineer. Regardless of where you are on that spectrum, algorithms and data structures matter. Not just as theoretical concepts, but as building blocks used to create solutions to business problems.

Sure, you may know how to use the C# List or Stack class, but do you understand what is going on under the covers? If not, are you really making the best decisions about which algorithms and data structures you are using?

Meaningful understanding of algorithms and data structures starts with having a way to express and compare their relative costs.

Asymptotic Analysis

When we talk about measuring the cost or complexity of an algorithm, what we are really talking about is performing an analysis of the algorithm when the input sets are very large. Analyzing what happens as the number of inputs becomes very large is referred to as asymptotic analysis. How does the complexity of the algorithm change when applied to ten, or one thousand, or ten million items? If an algorithm runs in five milliseconds with one thousand items, what can we say about what will happen when it runs with one million? Will it take five seconds or five years? Wouldn't you rather figure this out before your customer?

This stuff matters!

Rate of Growth

Rate of growth describes how an algorithm's complexity changes as the input size grows. This is commonly represented using Big-O notation. Big-O notation uses a capital O ("order") and a formula that expresses the complexity of the algorithm. The formula may have a variable, n, which represents the size of the input. The following are some common order functions we will see in this book but this list is by no means complete.

Constant - O(1)

An O(1) algorithm is one whose complexity is constant regardless of how large the input size is. The "1" does not mean that there is only one operation or that the operation takes a small amount of time. It might take one microsecond or it might take one hour. The point is that the size of the input does not influence the time the operation takes.

public int GetCount(int[] items)
    {
    	return items.Length;
    }
    

Linear - O(n)

An O(n) algorithm is one whose complexity grows linearly with the size of the input. It is reasonable to expect that if an input size of one takes five milliseconds, an input with one thousand items will take five seconds.

You can often recognize an O(n) algorithm by looking for a looping mechanism that accesses each member.

public long GetSum(int[] items)
    {
    	long sum = 0;
    	foreach (int i in items)
    	{
    		sum += i;
    	}
    
    	return sum;
    }
    

Logarithmic - O(log n)

An O(log n) algorithm is one whose complexity is logarithmic to its size. Many divide and conquer algorithms fall into this bucket. The binary search tree Contains method implements an O(log n) algorithm.

Linearithmic - O(n log n)

A linearithmic algorithm, or loglinear, is an algorithm that has a complexity of O(n log n). Some divide and conquer algorithms fall into this bucket. We will see two examples when we look at merge sort and quick sort.

Quadratic - O(n^2)

An O(n^2) algorithm is one whose complexity is quadratic to its size. While not always avoidable, using a quadratic algorithm is a potential sign that you need to reconsider your algorithm or data structure choice. Quadratic algorithms do not scale well as the input size grows. For example, an array with 1000 integers would require 1,000,000 operations to complete. An input with one million items would take one trillion (1,000,000,000,000) operations. To put this into perspective, if each operation takes one millisecond to complete, an O(n^2) algorithm that receives an input of one million items will take nearly 32 years to complete. Making that algorithm 100 times faster would still take 84 days.

We will see an example of a quadratic algorithm when we look at bubble sort.

Best, Average, and Worst Case

When we say an algorithm is O(n), what are we really saying? Are we saying that the algorithm is O(n) on average? Or are we describing the best or worst case scenario?

We typically mean the worst case scenario unless the common case and worst case are vastly different. For example, we will see examples in this book where an algorithm is O(1) on average, but periodically becomes O(n) (see ArrayList.Add). In these cases I will describe the algorithm as O(1) on average and then explain when the complexity changes.

The key point is that saying O(n) does not mean that it is always n operations. It might be less, but it should not be more.

What Are We Measuring?

When we are measuring algorithms and data structures, we are usually talking about one of two things: the amount of time the operation takes to complete (operational complexity), or the amount of resources (memory) an algorithm uses (resource complexity).

An algorithm that runs ten times faster but uses ten times as much memory might be perfectly acceptable in a server environment with vast amounts of available memory, but may not be appropriate in an embedded environment where available memory is severely limited.

In this book I will focus primarily on operational complexity, but in the Sorting Algorithms section we will see some examples of resource complexity.

Some specific examples of things we might measure include:

• Comparison operations (greater than, less than, equal to).
• Assignments and data swapping.
• Memory allocations.

The context of the operation being performed will typically tell you what type of measurement is being made.

For example, when discussing the complexity of an algorithm that searches for an item within a data structure, we are almost certainly talking about comparison operations. Search is generally a read-only operation so there should not be any need to perform assignments or allocate memory.

However, when we are talking about data sorting it might be logical to assume that we could be talking about comparisons, assignments, or allocations. In cases where there may be ambiguity, I will indicate which type of measurement the complexity is actually referring to.

Next Up

This completes the first part about algorithms and data structures. Next up, we'll move on to the linked list.