From different angles, two of our feature stories explore the role of humans in an automated world.

While we await Immanuel Kant’s perpetual peace, there will be wars; and if the president of the United States must sometimes defend the bad against the worse, perhaps it’s as well that he should make war with unmanned aerial vehicles, or drones.

The aim of this tutorial is to show off Python’s data structures and the best way to use them. Depending on what you need from a data structure, whether it’s fast lookup, immutability, indexing, etc, you can choose the best data structure for the job and most of the time, you will be combining data structures together to obtain a logical and easy to understand data model.

Introduction

Python data structures are very intuitive from a syntax point of view and they offer a large choice of operations. This tutorial tries to put together the most common and useful information about each data structure and offer a guide on when it is best to use one structure or another. You can choose different kinds of data structures depending on what the data involves, if it needs to be modified, or if it’s fixed data, and even what access type you would like, such as at the beginning/end/random etc.

Lists

A List represents the most versatile type of data structure in Python. It can contain items of different types and it has no rule against unicity. List indices start from zero, the elements can be sliced, concatenated, and so on. Lists also have a lot of similarities with strings, supporting the same kind of operations but unlike strings, lists are mutable.

How to Construct a List

A list can be built using the keyword list or using square brackets: [], both of which accept comma separated values. Here’s an example:

>>> l = ['a', 'b', 123]
    >>> l
    ['a', 'b', 123]
    

How to Retrieve an Element From a List

>>> l[0]
    'a'
    >>> l[10]
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    IndexError: list index out of range
    

As seen above, in order to access the data within your list, you must know what index position the element is at, otherwise you get an “index out of range” error.

How to Slice a List

All slicing operations return a shallow copy of the list. The slicing indexes are optional and they work in the same way as slicing indexes for strings.

Here’s an example of how to slice a list:

>>> l = ['a', 'b', 123]
    >>> l[:]
    ['a', 'b', 123]
    >>> new_l = l[1:]
    >>> new_l
    ['b', 123]
    >>> l
    ['a', 'b', 123]
    

Let’s take a look at some other common list operations.

Inserting and Removing Elements

>>> l = ['a', 'b', 123]
    >>> l.append(234) #inserts an element at the end of the list
    >>> l
    ['a', 'b', 123, 234]
    >>> l.insert(2, 'c') #inserts an element into the third position
    >>> l
    ['a', 'b', 'c', 123, 234]
    >>> l.insert(-1, 111) #inserts an element into the second from last position of the list (negative indices start from the end of the list)
    >>> l
    ['a', 'b', 'c', 123, 111, 234]
    >>> l.remove(111) #removes an element based on value
    >>> l
    ['a', 'b', 'c', 123, 234]
    >>> l.remove('does not exist in the list') 
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: list.remove(x): x not in list
    

Retrieving and Looking Up Elements

Lists can also be used as stacks or queues because of how easy it is to add and remove elements from the beginning or end of the list.

>>> last_element = l.pop() #returns the last element, modifying the list
    >>> last_element
    234
    >>> l
    ['a', 'b', 'c', 123]
    >>> third_element = l.pop(2) #returns the third element, modifying the list
    >>> third_element
    'c'
    >>> l
    ['a', 'b', 123]
    >>> l.index('a') 
    0
    >>> l.index('does not exist in the list')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: 'does not exist in the list' is not in list
    >>> l.count('a') #returns the number of occurrences of an element 
    1
    

Whole List Operations

>>> l.extend ([1, 2]) # concatenates a list on to the existing list
    >>> l
    ['a', 'b', 123, 1, 2]
    >>> l.sort()
    >>> l
    [1, 2, 123, 'a', 'b']
    >>> l.reverse()
    >>> l
    ['b', 'a', 123, 2, 1]
    

As you can see, it’s very easy to extend, sort, and reverse lists using the above methods.

List Comprehensions

A list comprehension means, constructing a list in a way that is very natural from a mathematical point of view. The code for doing this is brief and very easy to read. A simple example of when you would use list comprehensions is when you want to construct a new list based on the elements from another list. Let’s have a look at how you can multiply all of the elements of a numeric list by two, in a simple one line construct:

>>> l = [1, 2, 3]
    >>> new_l = [x*2 for x in l]
    >>> new_l 
    [2, 4, 6]
    

In the example above, the comprehension is represented by the multiplication expression that will be applied to every x element in the original, l list.

When to Use Lists

As shown in the examples above, lists are best used in the following situations:

• When you need a mixed collection of data all in one place.
• When the data needs to be ordered.
• When your data requires the ability to be changed or extended. Remember, lists are mutable.
• When you don’t require data to be indexed by a custom value. Lists are numerically indexed and to retrieve an element, you must know its numeric position in the list.
• When you need a stack or a queue. Lists can be easily manipulated by appending/removing elements from the beginning/end of the list.
• When your data doesn’t have to be unique. For that, you would use sets.

Sets

A set is an unordered collection with no duplicate values. A set can be created by using the keyword set or by using curly braces {}. However, to create an empty set you can only use the set construct, curly braces alone will create an empty dictionary.

Use the set keyword to create an empty set, curly brackets {} will create an empty dictionary.

How to Construct a Set

The set construct accepts one argument, a list.

>>> l = [1, 2, 3]
    >>> s = set(l)
    >>> s
    set([1, 2, 3])
    

The {} construct is straight forward as well:

>>> s = {1, 2, 3}
    >>> s
    

Sets are used to eliminate duplicate values from within a list:

>>> l = [1, 2, 3, 3]
    >>> s = set(l)
    >>> s
    set([1, 2, 3])
    

The way a set detects if a clash between non-unique elements has occurred is by indexing the data in memory, creating a hash for each element. This means that all elements in a set must be hashable.

Here is an example:

>>> set ([1, [1,2]])
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    

Note that a hashable object doesn’t necessarily mean that an object has the __hash__ method available to it. It is important that the hash of the object doesn’t change during its lifetime, which is obviously not the case with lists, sets, or dictionaries (dictionaries will be discussed later in this tutorial).

Set Operations

The set structure also supports mathematical operations like:

• Union
• Intersection
• Difference
• Symmetric Difference

Here are a few examples:

>>> set1 = set([1, 2, 3])
    >>> set2 = set([3, 4, 5])
    >>> set1 | set2 #union
    set([1, 2, 3, 4, 5])
    >>> set1 & set2 #intersection
    set([3])
    >>> set1 -  set2 #difference
    set([1, 2])
    >>> set1 ^ set2 #symmetric difference (elements that are in the first set and the second, but not in both)
    set([1, 2, 4, 5])
    >>> 
    

Set Comprehensions

Just like lists, sets also support comprehensions. Here is an example of how to use set comprehensions to find the unique consonants within a word:

>>> vowels = ['a', 'e', 'i', 'o', 'u']
    >>> {x for x in 'maintenance' if x not in vowels }
    set(['c', 'm', 't', 'n'])
    

Frozensets

A frozenset is basically just like a regular set, except that is immutable. It is created using the keyword frozenset, like this:

>>> frozen = frozenset([1, 2, 3])
    

When to Use Sets

You should choose to use a set in the following situations:

• When you need a unique set of data: Sets check the unicity of elements based on hashes.
• When your data constantly changes: Sets, just like lists, are mutable.
• When you need a collection that can be manipulated mathematically: With sets it’s easy to do operations like difference, union, intersection, etc.
• When you don’t need to store nested lists, sets, or dictionaries in a data structure: Sets don’t support unhashable types.

Tuples

Tuples are immutable, but can hold mutable objects.

A tuple is represented by a number of values separated by commas. Unlike lists, tuples are immutable and the output is surrounded by parentheses so that nested tuples are processed correctly. Additionally, even though tuples are immutable, they can hold mutable data if needed.

How to Construct a Tuple

Constructing an empty tuple requires parentheses. Here’s an example:

>>> my_empty_tuple = ()
    >>> my_empty_tuple 
    ()
    

Constructing a tuple with one element requires a trailing comma. Example:

>>> one_elem_tuple = 'a',
    >>> one_elem_tuple 
    ('a',)
    >>> one_elem_tuple = ('a',)
    >>> one_elem_tuple
    ('a',)
    

If the trailing comma is not there when creating a single element tuple, regardless if you use parentheses or not, Python will just interpret the value as a literal and will not create the tuple.

Constructing a tuple with multiple elements requires a list of values separated by commas. Here’s an example:

>>> s = 'a', 'b', [1, 2, 3]
    >>> s
    ('a', 'b', [1, 2, 3])
    >>> 
    

Tuples, from a performance point of view are great because of their immutability. Python will know exactly how much memory to allocate for the data to be stored.

When to Use Tuples

• When you need to store data that doesn’t have to change.
• When the performance of the application is very important. In this situation you can use tuples whenever you have fixed data collections.
• When you want to store your data in logical immutable pairs, triples etc.

Dictionaries

Dictionaries are represented by a key:value pair. In other words, they are maps or associative collections. The keys, unlike lists where they are numeric, can be of any immutable type and must be unique. The values can be of any type, mutable or immutable.

How to Construct a Dictionary

There are several ways to construct a dictionary. The most efficient way in terms of performance is to use curly braces {}:

>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
    >>> vowels
    {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5: 'u'}
    

Another way to create a dictionary is by using comprehensions. By using an input collection you can create the key:value pairs in one simple construct.

Here’s an example:

>>> {x:x*x for x in (1, 2, 3)}
    {1: 1, 2: 4, 3: 9}
    

You can also use the keyword dict and get the same result. The dict construct takes as an argument, a list of key:value pairs. Here’s one in action:

>>> dict([(1,'a'), (2,'e'), (3,'i'), (4,'o'), (5,'u')])
    {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5: 'u'}
    

If the keys are strings, you can use the following keyword expression:

>>> dict(a=1, e=2, i=3, o=4, u=5)
    {'i': 3, 'u': 5, 'e': 2, 'a': 1, 'o': 4}
    

However, it does not work the other way around when the keywords are numeric:

>>> dict(1=a, 2=e, 3=i, 4=o, 5=u)
      File "<stdin>", line 1
    SyntaxError: keyword can't be an expression
    

Dictionary Operations

Accessing data in a dictionary is very straight forward, just wrap its key name within square brackets:

>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
    >>> vowels[1]
    'a'
    >>> vowels[10]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 10
    >>> 
    

As seen above, a KeyError occurs if the key doesn’t exist in the dictionary.

Also, a key:value pair can be deleted using the del keyword, like so:

>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
    >>> del(vowels[1])
    >>> vowels
    {2: 'e', 3: 'i', 4: 'o', 5: 'u'}
    >>> del(vowels[10])
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 10
    >>> 
    

Built-in Methods

Dictionaries support many built-in methods, but some of the most useful ones are: keys(), values(), iteritems(), itervalues(), and has_key().

Here’s an example:

>>> vowels = {1: 'a', 2: 'e', 3: 'i', 4: 'o', 5:'u'}
    >>> vowels.keys()
    [1, 2, 3, 4, 5]
    >>> vowels.values()
    ['a', 'e', 'i', 'o', 'u']
    

The methods iteritems() and itervalues() return iterators, so they can be used in for loops. Here’s an example:

>>> for k, v in vowels.iteritems():
    ...     print k, v
    ... 
    1 a
    2 e
    3 i
    4 o
    5 u
    >>> for v in vowels.itervalues():
    ...     print v
    ... 
    a
    e
    i
    o
    u
    >>> 
    

When to Use a Dictionary

• When you need a logical association between a key:value pair.
• When you need fast lookup for your data, based on a custom key.
• When your data is being constantly modified. Remember, dictionaries are mutable.

Conclusion

General Python Data Structure Usage

• Use lists if you have a collection of data that does not need random access. For random access, you need to have knowledge of the element’s numeric index. Try to choose lists when you need a simple, iterable collection that is modified frequently. Lists are very useful in comprehension expressions for constructing sets or dictionaries.
• Use a set if you need unicity for the elements and you don’t need a nested dictionary or list. Also remember that a set cannot hold any unhashable data types.
• Use tuples when your data cannot change. Many times, a tuple is used in combination with a dictionary, for example, a tuple might represent a key, because it’s immutable.
• Use frozensets if you need both unique data and immutability.

Other Tips

• Every data structure has a multitude of built in methods and capabilities. If you go through them carefully you’ll learn how the data is meant to be used. For example, if you call dir and pass in a set object, you will see that it holds a lot of methods that can perform mathematical operations.
• Most of the time, your data needs to adapt to the operations that you want to perform. So if you know your object will be hashed, create an immutable structure.
• Most data structures have multiple ways of constructing or accessing its data. If you are concerned about the performance of your application always read the documentation or read the source code of the construct implementation to find out more about its performance. For example, creating a dictionary by using dict offers less performance than using the curly braces ({}) syntax.
• While debugging, many developers find it useful to learn how to identify and connect the error that they are receiving to a specific data structure. For example, you’ll find that lists throw IndexError and ValueError and dictionaries throw KeyError. This technique should help you with detecting which of your data structures is causing the error.

Today we look at Sencha Animator, a program which allows you to create CSS3 animations. These animations are designed to have a similar look and feel as Flash, but with CSS3 and HTML5.

UMBC President Freeman A. Hrabowski, III, takes your questions.

Q:  I want to thank you for making me proud to have a degree from UMBC. The legacy you are building not only enriches students’ experiences, but adds value to their postgraduate lives. How will you continue the momentum you’ve built – and specifically where will additional capital be directed in the coming years?

– John Becker ’01, information systems

A:  Wherever I go in the country, people talk about UMBC as a university that is setting a standard for inclusive excellence. So how do we keep the momentum?

First, I think of academic innovation. We need to think about how we use technology and how we prepare students to solve problems in groups. Interdisciplinarity is also a focus for us in increasingly important ways.

We are involved in a number of experiments at UMBC to pursue those questions. We are working with the Howard Hughes Medical Institute on how we prepare students for medical school. We’re exploring the digital humanities and how we teach writing at UMBC. We are working with the Gates Foundation on how we connect to community colleges, and also with the National Science Foundation to determine which strategies help students succeed.

As a result, we have created a culture that focuses on trying different approaches. We use analytics to assess the effectiveness of different strategies, and then set our direction based on that analysis. We’re going to continue those efforts as we also continue to find resources to attract the best faculty across disciplines to UMBC.

There have also been significant investments in the physical infrastructure of the university. People who have not been to campus in the past few years are always amazed at how much the place has been transformed. We recently opened the first phase of the Performing Arts and Humanities Building. It is the most expensive building in the history of UMBC.

And over the next several years the university will be transformed even more. We hope to have a new Events Center that will not only be supportive of academically-sound athletics, but will also give the entire campus a greater opportunity to be physically fit. And we are also delighted that our governor, Martin O’Malley, has moved a new Interdisciplinary Life Sciences Building forward in the queue for state funding.

It is the investments we are making in academic innovation and in people – coupled with our investments in the physical infrastructure on campus – that will shape UMBC in the future.

Q:  Given the injustices you’ve had to overcome to reach your level of success, what are a few guiding principles you’ve used to maintain a positive and productive attitude?

— John Garnet ’06, financial economics

A:  I continue to recommend David Brooks’ book The Social Animal. We think that we determine our actions and attitudes based on logic and a rational approach, yet research shows us that much of what we decide to do can be attributed to things that happened to us as children – many of them which we have forgotten.

For me, growing up in such a loving family, with very hard-working and positive parents who emphasized the importance of love and respect for each other, made all the difference in the world. I saw them in different ways being insulted and challenged by a rigid and prejudiced society – but they never became bitter or cynical. And they always believed that every human being had the potential to be a good person. And when they witnessed people being mean-spirited they believed that they were the product of their childhood experiences; that these people clearly hadn’t had the benefit of love.

I didn’t believe them at first. But as I have gotten older, I appreciate their approach much more. They told me that the people who tend to be happiest have to be realistic – on the one hand – but also to have as much optimism as possible. To find the good in whatever the situation is. Even in tragedy, to ask the question: What can I learn from this?

I am on UMBC’s campus almost every working day. As the editor of UMBC Magazine, that’s not unexpected. It’s my job.

But before I became editor, I came back to UMBC a number of times after graduating in 1986. Sometimes I returned to see a former professor. Other times, I was invited to speak to young journalists, or a new generation of Bartleby editors. I also attended alumni events.

The staff of our alumni relations department work hard to come up with events that will entice you to reconnect with the university and your fellow alumni. These events include talks given by UMBC professors on the cutting edge of research in various disciplines, wine tastings and gallery openings, and even a chance to take in ball games at Orioles Park at Camden Yards or Nationals Stadium.

Over the past few years, it’s been a delight to watch many of my fellow alumni make the trek home to UMBC. What they see when they get here isn’t just a campus filled with memories – but also a university that’s growing and thriving across disciplines.

Just this past April, UMBC alumni gathered on campus for a number of events. Over 60 ancient studies alumni came back to celebrate their program’s remarkable history and honor a number of the founding faculty of the department. And 70 alumni from UMBC’s award-winning theatre program came back to celebrate the opening of the new Performing Arts and Humanities Building with their department’s faculty (below) and to see William Shakespeare’s The Two Gentlemen of Verona –  the first production in a the new building’s proscenium theatre.

Have a look at our calendar on the back page of this issue – or, better yet, sign up and get information about all of our upcoming events – including Homecoming 2013 – via our online alumni portal Retriever Net.

I’m sure you’ll find something that will bring you back to visit us here at UMBC.

– Richard Byrne ’86

CALL TO HISTORY

The proscenium theatre of UMBC’s recently-opened Performing Arts and Humanities Building was perhaps the most appropriate venue for this year’s W. Augustus Low Lecture in History.

The lecturer was John Jeffries, dean of UMBC’s College of Arts, Humanities and Social Sciences (CAHSS) and professor of history, who will retire from the university on June 30. Among the greatest legacies of his 40 years of scholarship and service to UMBC – much of it as leader of the Faculty Senate and the college – was his guiding hand in making the new building a reality, and literally cementing the university’s continuing commitment to the arts and humanities.

The capacity crowd gave Jeffries two standing ovations – both before and after his lecture, which was entitled “A Life in History: Reflections on Studying Politics and Policy in Twentieth Century America.”

The lecture took the audience through Jeffries’ journey from majoring in history as an undergraduate on a Navy ROTC scholarship at Harvard University in the late 1950s and early 1960s and a five year career in the U.S. Navy to graduate studies at Yale University and a career in academe that took hold at UMBC in 1973.

Yet Jeffries’ lecture was as much a tale of the shifting currents in the study of his chosen subject – 20^th century electoral politics and policy in the United States – as it was a personal reminiscence.  Jeffries recalled the excitement of entering the discipline when the “new political history” was in the ascendance. It was a moment when historians were reshaping the field with “systematic, quantitative and social-science approaches to the study of American politics” and seeking to uncover larger currents and patterns in the nation’s political history.

Though the “new political history” itself was subject to critiques and corrections in subsequent decades, Jeffries made a compelling case for its emphasis on the centrality of “ethnocultural attachments and antagonisms in voting” by pointing to the persistence of its influence in recent elections.

Jeffries also explained his own shift as a historian away from studies of voting to the wider seas of how election results played out in the policies enacted by elected officials – with special attention to the era of the New Deal. “I have tried to root my study of policymaking in the matrices of politics and public opinion,” he said, “not just the documents found in archives.”

Asked in the question-and-answer session after the lecture what his advice would be to future students of history, Jeffries had a simple and straightforward reply: “Work hard and have fun. I’ve really enjoyed my life in history…. Enjoy what you’re doing.”

At the end of the lecture, UMBC president Freeman A. Hrabowski, III capped off the event by announcing that Jeffries had been named by the university as both a professor emeritus of history and a dean emeritus of the college.

Members of the CAHSS faculty also announced that a new John Jeffries International Fellowship was being established to provide UMBC faculty with resources to create, or redesign, and teach a course in their fields with an explicit international or transnational focus.

– Richard Byrne ’86

– Watch Dean Jeffries’ lecture here.

Interested in helping to endow the John Jeffries International Fellowship? Point your browser to UMBC’s online giving site to select an amount and type “John Jeffries Fellowship” in the “Other Designation” line provided in the web form.

TIME PASSAGES

As UMBC prepares to celebrate its 50th anniversary in 2016, the university will mark a number of landmark dates in its founding. The first of them, in fact, fell in late April of this year, with the 50th anniversary of the passage of the legislation that authorized UMBC’s founding.

The legislation implemented some of the recommendations made by a 1962 state commission on expanding higher education in Maryland. The bill itself was sponsored by longtime Baltimore County Senator James A. Pine, Sr., who was also chair of the Maryland Senate’s Economic Affairs Committee. Pine died in 1988 at the age of 85.

While the 1963 legislation authorized the building of four new branches of the University of Maryland (including locations in the state’s western and southern regions and on the Eastern Shore), UMBC was the only university actually founded as a result of the legislation.

The bill also specifically mentions that the university would not only alleviate overcrowding at other state universities, but also serve as a “nucleus for scientific research and development” in Baltimore County – a definition of its mission which has been amply fulfilled over more than four decades.

UMBC was also the first public university founded in Maryland after the state fully desegregated its higher education system in 1954.

“This university was founded at a time when people of all races could come here and study,” says UMBC president Freeman A. Hrabowski, III. “We are a part of an experiment in which America has been engaged, providing public higher education in an atmosphere of excellence and diversity.”

– Richard Byrne ’86

Image provided by the Maryland Archives

KICK IN

Stroll near the Commons on most weekdays and you’ll see tables piled high with tasty baked goods, or featuring games of chance. The students at these tables are asking for help – spare change, really – to fund their clubs’ latest and greatest pursuits in a way that hasn’t changed much since the university opened in 1966.

But now these passionate student appeals are now getting a boost from the power of the Internet via GiveCorps, UMBC’s newest fundraising tool. The UMBC pilot of GiveCorps – which focuses on university needs as well as student causes – has just launched online, harnessing social media’s power to publicize, track and aggregate philanthropic campaigns.

“We are incredibly excited to work with student groups to help them understand the ins and outs of philanthropy through GiveCorps,” says Dayna Carpenter, UMBC’s associate director of annual giving. “Our students are very motivated to do good in this world, and this is an important element of their education.”

The GiveCorps site already boasts colorful channels to help student causes. Visitors can help the SAE Mini Baja team get to their next competition, for instance, or send students from Engineers Without Borders to Kenya to dig wells. Donors can also support university giving that directly benefits current students, including the Stay Black and Gold Fund for those who have emergency financial needs.

“The best part is that this lets the students take the lead in promoting their own projects using social media,” says Carpenter. “They’re really good at that, already, so this should feel like a natural fit.”

— Jenny O’Grady

– Visit UMBC’s GiveCorps site here.

When Stephanie Hill ’86, computer science and economics, signed up for her first computer programming class at UMBC, it was almost as an afterthought – an elective to fill out the semester.

That class in the programming language COBOL led Hill to become (in her words) an “accidental engineer.” And however serendipitous her start in engineering may have been, she’s been quite a success. At Lockheed Martin’s Information Systems & Global Solutions-Civil division, Hill oversees some of the largest government computer systems in operation today. She’s also been honored by the university as one of its 2012 Alumni of the Year.

At UMBC, Hill says she learned that she “loved the problem-solving aspect” of programming and software engineering. “You could make things happen. It took me to a new level of satisfaction, figuring out a problem and being able to see the answer,” Hill says. She also cites a three-year professional practice co-op that UMBC had set up with the Department of Labor during her time at the university as instrumental in setting the stage for her success.

The problems that Hill tackles now at Lockheed Martin involve immense complexity. Her division is responsible for the company’s work with U.S. civil federal agencies and other government agencies worldwide – tasks that demand the smooth operation of many large computer systems that Hill’s group oversees.

If you’ve been on an airplane, you likely have flown through airspace managed by an air traffic control system that Hill’s division at Lockheed Martin runs on behalf of the Federal Aviation Administration. Those who served in the armed forces may use a disability system Hill oversees for the Department of Veterans Affairs, and anyone who has drawn on the resources provided by Medicare or Medicaid also depends on the work in Hill’s division.

“We literally impact the lives of American citizens every day,” Hill says.

Soon after graduating from UMBC, Hill took a job with defense contractor Martin Marietta. The only open position was in software testing, but she let the company know she was eager to be in software engineering.

Hill proved her mettle and was promoted to software engineer within a few years. Ever since, she has tirelessly worked up through the ranks of the company (which in 1995 merged with Lockheed Corporation to become Lockheed Martin) in roles of increasing responsibility that included positions as the company’s Director of Quality and Mission Success and as its Director of Technical Operations.

As she has risen to greater prominence, Hill has also been visible as a leader in efforts to help more women and minorities follow her into careers in engineering.

As Hill pointed out in an op-ed she wrote for The Washington Post in May 2012, only 14 percent of engineers today are women, and only 6 percent of those working in the fields of science, technology, engineering, and mathematics (STEM) are black or Hispanic.

One problem in boosting those dismal numbers is that many women and minorities don’t see role models in their neighborhoods and schools – a reason why Hill has served as a mentor to many UMBC students.

“We have a real responsibility to share what we do,” she says. She is also a member of the state of Maryland’s STEM Task Force, which seeks ways to encourage more learning in the sciences.

“I never imagined I’d have the opportunities that I have had. I want other people to experience it,” Hill says. “Seeing people blossom and become leaders is very motivating and satisfying.”

Hill says one of the biggest misconceptions people have about engineering is that it is a job for introverts. In fact, she says, much of her time at Lockheed Martin is spent working with others – meeting employees for first-hand accounts of what’s happening in the field, or checking in with customers to make sure their expectations are met.

Pursuing a career in engineering doesn’t mean that “you are sitting behind the desk with your head down, not talking to anybody,” Hill says. “There is some of that individual work, but most of the work we do we do in a team. And we do some of the most exciting things any career could offer.”

– Joab Jackson ’90

Read more about Hill’s piece in the Washington Post here.