For almost a decade, the Alliance for Women in Media Foundation (AWMF) has been telling the stories of inspiring women from American history with its Empowering America program. In 2008, AWMF expanded the Empowering America program to share the stories of these women with middle schools across the country.

In partnership with the Ford Motor Company Fund, the philanthropic arm of Ford Motor Company, AWMF developed educational collateral and put it in the hands of teachers to stimulate and enhance classroom conversations about these female icons, who have pioneered in fields such as science, social reform, public service, sports, journalism, music and aviation. Past subjects of Empowering America programs include Annie Easley, Gloria Estefan, Gabrielle Giffords, Barbara Jordan, Christa McAuliffe, Muriel Siebert, Sonia Sotomayor, and many more.

Submission Requirements: Please submit a proposed script for the video along with a sample of previous video work and letter of recommendation from a professor or media professional. The script must include and incorporate the competition theme, Blazing the Trail: Celebrating the Women of Empowering America, and feature at least four women from the 2013 Empowering America program (booklet available here). Here are some questions to consider:

In what ways have these women influenced the course of American history? What can we learn from them?

What positive qualities do these women possess that could speak to students or future leaders?

How do these women leaders and their legacies continue to impact us today?

We encourage you to look at the 2013 Empowering America booklet to get a sense of the featured women, their accomplishments and their journeys. You are not required to focus on all of the women featured in the booklet, but must include a representative sample.

You must be full‐time undergraduate or graduate student at an accredited college or university. Please include with your submission the following information in its entirety:

Name

College or University, Expected Year of Graduation

Contact Information (mailing address, phone, email)

Copy of a valid student ID

A proposed script/outline for the two to three‐minute video, as described above

A sample of previous video work

A letter of recommendation from a media professor or media professional

Prize: AWMF and Ford Motor Company Fund will select one student winner to receive $5,000, payable to the winning student’s educational institution upon completion of the video. All production expenses are incurred by the student.

Selection: The script, sample video and recommendation along with any collateral are due December 16, 2013. A panel consisting of representatives from AWMF and Ford Motor Company Fund will choose the winning student. The winning student will be notified by December 20, 2013 with production to occur in December 2013/January 2014. The final video must be completed and received by February 20, 2014 and must include an AWMF‐provided tag line. The video must be cleared for the uses noted below. We will launch the video as part of our Women’s History month initiative.

The winning video will be posted on the AWMF web site for use by middle schools across the country, as well as incorporated into the Empowering America program wherever possible.

The video will be prominently distributed and displayed on AWM’s and social media outlets.

Determinations of appropriateness will be made in the sole discretion of AWM and Ford Motor Company Fund.

Application materials will not be returned to the student.

Employees of Ford Motor Company (sponsor), their subsidiaries, affiliates, and immediate family members are not eligible for the contest. Void where prohibited.

Another chance to catch the most interesting, and important, articles from the previous week on MIT Technology Review.

Single Responsibility (SRP), Open/Close, Liskov’s Substitution, Interface Segregation, and Dependency Inversion. Five agile principles that should guide you every time you write code.

The Definition

A class should have only one reason to change.

Defined by Robert C. Martin in his book Agile Software Development, Principles, Patterns, and Practices and later republished in the C# version of the book Agile Principles, Patterns, and Practices in C#, it is one of the five SOLID agile principles. What it states is very simple, however achieving that simplicity can be very tricky. A class should have only one reason to change.

But why? Why is it so important to have only one reason for change?

In statically typed and compiled languages, several reasons may lead to several, unwanted redeployments. If there are two different reasons to change, it is conceivable that two different teams may work on the same code for two different reasons. Each will have to deploy its solution, which in the case of a compiled language (like C++, C# or Java), may lead to incompatible modules with other teams or other parts of the application.

Even though you may not use a compiled language, you may need to retest the same class or module for different reasons. This means more QA work, time, and effort.

The Audience

Determining the one single responsibility a class or module should have is much more complex than just looking at a checklist. For example, one clue to find our reasons for change is to analyze the audience for our class. The users of the application or system we develop who are served by a particular module will be the ones requesting changes to it. Those served will ask for change. Here are a couple of modules and their possible audiences.

• Persistence Module – Audience include DBAs and software architects.
• Reporting Module – Audience include clerks, accountants, and operations.
• Payment Computation Module for a Payroll System – Audience may include lawyers, managers, and accountants.
• Book Search Module for a Library Management System – Audience may include the librarian and/or the clients themselves.

Roles and Actors

Associating concrete persons to all of these roles may be difficult. In a small company a single person may need to satisfy several roles while in a large company there may be several persons allocated to a single role. So it seems much more reasonable to think about the roles. But roles by themselves are quite difficult to define. What is a role? How do we find it? It is much easier to imagine actors doing those roles and associating our audience with those actors.

So if our audience defines reasons for change, the actors define the audience. This greatly helps us to reduce the concept of concrete persons like “John the architect” to Architecture, or “Mary the referent” to Operations.

So a responsibility is a family of functions that serves one particular actor. (Robert C. Martin)

Source of Change

In the sense of this reasoning, actors become a source of change for the family of functions that serves them. As their needs change, that specific family of functions must also change to accommodate their needs.

An actor for a responsibility is the single source of change for that responsibility. (Robert C. Martin)

Classic Examples

Objects That Can “Print” Themselves

Let’s say we have a Book class encapsulating the concept of a book and its functionalities.

class Book {
    
    	function getTitle() {
    		return "A Great Book";
    	}
    
    	function getAuthor() {
    		return "John Doe";
    	}
    
    	function turnPage() {
    		// pointer to next page
    	}
    
    	function printCurrentPage() {
    		echo "current page content";
    	}
    }

This may look like a reasonable class. We have book, it can provide its title, author and it can turn the page. Finally, it is also able to print the current page on the screen. But there is a little problem. If we think about the actors involved in operating the Book object, who might they be? We can easily think of two different actors here: Book Management (like the librarian) and Data Presentation Mechanism (like the way we want to deliver the content to the user – on-screen, graphical UI, text-only UI, maybe printing). These are two very different actors.

Mixing business logic with presentation is bad because it is against the Single Responsibility Principle (SRP). Take a look at the following code:

class Book {
    
    	function getTitle() {
    		return "A Great Book";
    	}
    
    	function getAuthor() {
    		return "John Doe";
    	}
    
    	function turnPage() {
    		// pointer to next page
    	}
    
    	function getCurrentPage() {
    		return "current page content";
    	}
    
    }
    
    interface Printer {
    
    	function printPage($page);
    }
    
    class PlainTextPrinter implements Printer {
    
    	function printPage($page) {
    		echo $page;
    	}
    
    }
    
    class HtmlPrinter implements Printer {
    
    	function printPage($page) {
    		echo '<div style="single-page">' . $page . '</div>';
    	}
    
    }

Even this very basic example shows how separating presentation from business logic, and respecting SRP, gives great advantages in our design’s flexibility.

Objects That Can “Save” Themselves

A similar example to the one above is when an object can save and retrieve itself from presentation.

class Book {
    
    	function getTitle() {
    		return "A Great Book";
    	}
    
    	function getAuthor() {
    		return "John Doe";
    	}
    
    	function turnPage() {
    		// pointer to next page
    	}
    
    	function getCurrentPage() {
    		return "current page content";
    	}
    
    	function save() {
    		$filename = '/documents/'. $this->getTitle(). ' - ' . $this->getAuthor();
    		file_put_contents($filename, serialize($this));
    	}
    
    }

We can, again identify several actors like Book Management System and Persistence. Whenever we want to change persistence, we need to change this class. Whenever we want to change how we get from one page to the next, we have to modify this class. There are several axis of change here.

class Book {
    
    	function getTitle() {
    		return "A Great Book";
    	}
    
    	function getAuthor() {
    		return "John Doe";
    	}
    
    	function turnPage() {
    		// pointer to next page
    	}
    
    	function getCurrentPage() {
    		return "current page content";
    	}
    
    }
    
    class SimpleFilePersistence {
    
    	function save(Book $book) {
    		$filename = '/documents/' . $book->getTitle() . ' - ' . $book->getAuthor();
    		file_put_contents($filename, serialize($book));
    	}
    
    }
    

Moving the persistence operation to another class will clearly separate the responsibilities and we will be free to exchange persistence methods without affecting our Book class. For example implementing a DatabasePersistence class would be trivial and our business logic built around operations with books will not change.

A Higher Level View

In my previous articles I frequently mentioned and presented the high level architectural schema that can be seen below.

If we analyze this schema, you can see how the Single Responsibility Principle is respected. Object creation is separated on the right in Factories and the main entry point of our application, one actor one responsibility. Persistence is also taken care of at the bottom. A separate module for the separate responsibility. Finally, on the left, we have presentation or the delivery mechanism if you wish, in the form of an MVC or any other type of UI. SRP respected again. All that remains is to figure out what to do inside of our business logic.

Software Design Considerations

When we think about the software that we need to write, we can analyze many different aspects. For example, several requirements affecting the same class may represent an axis of change. This axes of change may be a clue for a single responsibility. There is a high probability that groups of requirements that are affecting the same group of functions will have reasons to change or be specified in the first place.

The primary value of software is ease of change. The secondary is functionality, in the sense of satisfying as much requirements as possible, meeting the user’s needs. However, in order to achieve a high secondary value, a primary value is mandatory. To keep our primary value high, we must have a design that is easy to change, to extend, to accommodate new functionalities and to ensure that SRP is respected.

We can reason in a step by step manner:

1. High primary value leads in time to high secondary value.
2. Secondary value means needs of the users.
3. Needs of the users means needs of the actors.
4. Needs of the actors determines the needs of changes of these actors.
5. Needs of change of actors defines our responsibilities.

So when we design our software we should:

1. Find and define the actors.
2. Identify the responsibilities that serve those actors.
3. Group our functions and classes so that each has only one allocated responsibility.

A Less Obvious Example

class Book {
    
    	function getTitle() {
    		return "A Great Book";
    	}
    
    	function getAuthor() {
    		return "John Doe";
    	}
    
    	function turnPage() {
    		// pointer to next page
    	}
    
    	function getCurrentPage() {
    		return "current page content";
    	}
    
    	function getLocation() {
    		// returns the position in the library
    		// ie. shelf number & room number
    	}
    
    }

Now this may appear perfectly reasonable. We have no method dealing with persistence, or presentation. We have our turnPage() functionality and a few methods to provide different information about the book. However, we may have a problem. To find out, we might want to analyze our application. The function getLocation() may be the problem.

All of the methods of the Book class are about business logic. So our perspective must be from the business’s point of view. If our application is written to be used by real librarians who are searching for books and giving us a physical book, then SRP might be violated.

We can reason that the actor operations are the ones interested in the methods getTitle(), getAuthor() and getLocation(). The clients may also have access to the application to select a book and read the first few pages to get an idea about the book and decide if they want it or not. So the actor readers may be interested in all the methods except getLocations(). An ordinary client doesn’t care where the book is kept in the library. The book will be handed over to the client by the librarian. So, we do indeed have a violation of SRP.

class Book {
    
    	function getTitle() {
    		return "A Great Book";
    	}
    
    	function getAuthor() {
    		return "John Doe";
    	}
    
    	function turnPage() {
    		// pointer to next page
    	}
    
    	function getCurrentPage() {
    		return "current page content";
    	}
    
    }
    
    class BookLocator {
    
    	function locate(Book $book) {
    		// returns the position in the library
    		// ie. shelf number & room number
    		$libraryMap->findBookBy($book->getTitle(), $book->getAuthor());
    	}
    
    }

Introducing the BookLocator, the librarian will be interested in the BookLocator. The client will be interested in the Book only. Of course, there are several ways to implement a BookLocator. It can use the author and title or a book object and get the required information from the Book. It always depends on our business. What is important is that if the library is changed, and the librarian will have to find books in a differently organized library, the Book object will not be affected. In the same way, if we decide to provide a pre-compiled summary to the readers instead of letting them browse the pages, that will not affect the librarian nor the process of finding the shelf the books sits on.

However, if our business is to eliminate the librarian and create a self-service mechanism in our library, then we may consider that SRP is respected in our first example. The readers are our librarians also, they need to go and find the book themselves and then check it out at the automated system. This is also a possibility. What is important to remember here is that you must always consider your business carefully.

Final Thoughts

The Single Responsibility Principle should always be considered when we write code. Class and module design is highly affected by it and it leads to a low coupled design with less and lighter dependencies. But as any coin, it has two faces. It is tempting to design from the beginning of our application with SRP in mind. It is also tempting to identify as many actors as we want or need. But this is actually dangerous – from a design point of view – to try and think of all the parties from the very beginning. Excessive SRP consideration can easily lead to premature optimization and instead of a better design, it may lead to a scattered one where the clear responsibilities of classes or modules may be hard to understand.

So, whenever you observe that a class or module starts to change for different reasons, don’t hesitate, take the necessary steps to respect SRP, however don’t overdue it because premature optimization can easily trick you.

by Karly Trinite

Before I applied for my internship with UMBC Off-Campus Student Services, I knew it was right for me. My passion throughout college was always taking the information I learned as an environmental studies student and sharing and applying it beyond the walls of my classes... (continue reading)

One of the biggest hurdles when creating a responsive website is implementing the navigation – hands down. Not just from a design standpoint, but from a content and development standpoint as well. Debatably the most important element on the page, a user should have no issues as they try to navigate around your website no matter what device they are on.

So what are the latest design patterns? And what are the best plugins? Before browsing Dribbble for inspiration and GitHub for resources, step back and determine what your specific challenges are, and what type of solution would be most effective for the project at hand.

Content

When structuring your responsive menu and its content, do so with mobile in mind first. Designing for constraints allows you to revisit the content of your website and determine what may or may be necessary to include. This applies to your entire website, but especially the navigation. If a navigational item doesn’t make the cut on the mobile website, is it really worth including on the site or in the primary navigation at all? Should it instead live within a secondary or utility navigation? Designing responsive websites enables us to think with laser focus and create a lean, efficient online experience.

Design

There are tons of various design solutions for responsive websites coming out of the woodwork. And many of them are becoming recognized design patterns. Some responsive navigations use the “do nothing” approach where they simply shrink down with the grid of your responsive website, while others collapse and hide, and can be viewed by clicking on an icon.

Treehouse collapses the navigation into an icon for smaller viewports that can be clicked to reveal the full navigation.

While these design solutions might work for smaller navigations, larger websites might not be able to escape their complex, multi-level navigation. And that’s ok. It’s all about determining what design solution best fits your navigation’s content and is best for the project at hand.

Development

Another factor to keep in mind when creating a responsive navigation are what type of development requirements you might have. If your navigation is built using JavaScript, how will it appear to users who have JS disabled? If you have a dropdown navigation, how is the delay between the physical tap and the menu’s responsiveness to then drop down? When looking for the best solution for your responsive navigation be sure it addresses your development concerns in addition to your design preferences.

Solutions

CSS Frameworks

Many CSS Frameworks have built reusable components including navigation into their solutions. And typically, they are built to give you tons of control in how they are styled. If you’re already using a CSS framework, check the documentation for options to implement a navigation into your responsive website before unwittingly including additional and unnecessary code. Here are a couple popular frameworks that already include responsive navigation.

• Twitter Bootstrap
  http://getbootstrap.com/components/#navbar

  Version 3 of Bootstrap offers a navigation that by default, begins collapsed and toggleable in mobile views and becomes horizontal as the viewport width increases.

  

• Zurb Foundation
  http://foundation.zurb.com/docs/components/topbar.html

  Foundation 5 offers an off-canvas navigation that slides into the viewport when activated, a more traditional collapsing navigation and fixed position nav bar.

  

Plugins

There may be a scenario where you aren’t using a CSS framework or one that includes a responsive navigation, and using the navigation from these frameworks might prove difficult to use alone with dependencies. There’s absolutely no shame in taking advantage of resources others have created to get you started. Here are a few popular plugins.

• ResponsiveNav
  http://responsive-nav.com

  With a previous iteration known as “TinyNav”, ResponsiveNav is effective for simple navigations and easy to implement, this tiny JavaScript plugin uses touch events and CSS3 transitions for the best possible experience.

  

• FlexNav
  http://jasonweaver.name/lab/flexiblenavigation/

  A great solution for websites that can’t escape multi-level navigations, this plugin pays special attention to touch screens using tap targets, the key feature of FlexNav.

  

• Sidr
  http://www.berriart.com/sidr/

  A powerful plugin that handles both left and right slide in menus, this plugin also handles touch events on mobile devices.

  

Custom Solution

Creating a custom solution is always an option, and you don’t have to rub shoulders with a developer to make it happen. It’s much simpler than you might think, depending on the complexity of your navigation. Our very own Andrew Chalkley created a great blog post awhile back on “How to Build a “Three Line” Drop-down Menu for a Responsive Website in jQuery.”

Conclusion

When implementing your responsive navigation, avoid instinctively following trends and step back and observe your project objectively. Which responsive navigation solution makes the most sense and would be most effective for the end user to navigate? Determine your challenges by first focusing the content of your navigation, secondly deciding which design solution best fits that content, and lastly which development approach best achieves that design.

The post Challenges & Solutions for Your Responsive Navigation appeared first on Treehouse Blog.

1. Most Campus IT Services Unavailable on 12/30/13
2. Reminder: Blackboard to be Upgraded January 8-10, 2014 
3. WT & SP 2014 Bb Course Shells Created on 12/2
4. TSC Announces Winter Hours Starting 12/19/13
5. DoIT and FDC Offer Hybrid Workshop on 1/14/13
6. DoIT & MCS Offer Digital Storytelling on the iPad Workshop 1/22 & 1/23
7. Skype Video Conference Room Established
8. DoIT Runs FA2013 Pilot Comparing Clickers vs. Scantrons
9. Informal DoIT Drop-Ins to Focus on Web-based Technologies
10. Support For Windows XP ends April 1, 2014