GSA annually funds more than 300 UMBC graduate students’ research and travel with an average of $140,000 expended. This graduate assistantship is the project manager for GSA Research & Travel (R&T) including upkeep of the R&T database, coordinating R&T processes, analyzing R&T data, and producing monthly, semester and annual reports which assist the GSA Executive Board’s strategic planning and budgeting processes.

This graduate assistantship requires knowledge of computer databases, website management, project management and systems processes. The position requires design, trouble-shooting, research, and analysis as well as the ability to work alone and on a team. Duties include database management and research on GSA R&T funding.

This position chairs the GSA Senate Travel & Research Committee, working in collaboration with GSA Senators and Executive Board members to create more efficient processes and effective reports. The GA will have a sense of project management to assist with events and long-term projects. The GA in this position should have a background in the following topics: database implementation, project management, decision technology, information management, emerging technologies.

Responsibilities: 65% database and R&T project management; 25% website management; 10% recruitment.

This is a 20-hour/week assistantship including tuition remission, stipend & GA health insurance. Stipends http://www.umbc.edu/gradschool/funding/minimum_stipend_levels.html

Send an application letter, CV, a copy of your UMBC unofficial transcripts, and contact information for 2-3 faculty/UMBC references to Dr. Jenness E. Hall hall@umbc.edu with the subject “R&T GA Position.”

Interviews will commence immediately. Position available January 6. 2014.

On October 28th, I tweeted that I was looking to hire a freelance front-end web developer for Uncover:

I’ve got a quick frontend freelance gig for someone. Please @ message me or email me if interested.

— Spencer Fry (@spencerfry) October 28, 2013

I thought I would give it a shot, now knowing what to expect. While I may have more Twitter followers than some (5,250+), I didn’t think I’d get more than a lead or two. What I definitely didn’t expect was to interview five competent people the next day: four over Skype and one in person in New York City.

Within minutes, I had several people reply to my tweet that they’d be interested in the job. I responded to them with my email address and we set up a chance to talk the following day. By the end of the day I had five scheduled meetings in my calendar for the following day. Two of the people were local in NYC, one was in the UK, one was in Belgium, and the fifth was in San Francisco. The following morning before I started the interviews I tweeted:

I'll have interviewed 5 frontend developers for a quick gig by the end of today. All thanks to intros via Twitter.

— Spencer Fry (@spencerfry) October 29, 2013

I was giddy at the thought that a single tweet could land me a freelancer.

The interviews proceeded on schedule and I talked to each of the candidates for between fifteen and twenty minutes. I emailed each of them three PNG files that represented the PSDs that needed to be converted into HTML and CSS. I then explained that Uncover is written in Ruby on Rails and asked what their experience was with implementing HTML/CSS in that environment. They all had experience with RoR. We also use a rather obscure views and templates engine called Mustache and I wanted to find out whether anyone had used it. One had heard of it, but nobody had used it. I then asked them a series of short questions to gauge their experience and to find out how they would complete the actual work. What was their process? Where would they start?

After interviewing all the candidates, I had a sense of who would be the best person for the job, but I needed to wait for quotes before making my decision. I gave each candidate until the following morning to get back to me with a quote. Only one of the five sent a proposal right after we’d talked. The quotes ranged from as little as $750 to as much as $1650 with the average being at just over $1,000. I could tell from speaking with the $750 person that he was the least experienced of the group. Four of the five quotes were hourly and one was project based. I ended up negotiating down the $1,650 guy, the one who had given the project based quote, to $1,200 after another Skype call with him.

I explained to him that $1,650 was $550 higher than the next highest quote, but that I’d be willing to pay a premium because of his experience and that he was located in New York. While I’m all for remote workers, I’m willing to pay slightly more knowing that we could grab coffee or meet briefly at our office if it was necessary. At this time, we haven’t needed to.

We signed the contract and began work the next day. Immediately after signing the contract, I reached out to the other four candidates and let them know that I appreciated their time but that I had gone with someone else. Everyone wrote back with nice emails. The worst thing you can do is to take your time making your decision when hiring someone as a freelancer, because it’s unfair to the people you don’t go with. They’re left waiting, not knowing what’s going to happen or whether their time has been booked.

Finding this freelancer through Twitter has been an amazing experience. I went from a single tweet asking for a freelance front-end developer to a signed contract in under 48 hours. I’ve hired dozens of freelancers, but nothing even close to that short a timeframe has ever happened to me before.

It’s amazing to see the value that being on Twitter can bring you. I would never have been able to find five developers to interview in such a short period of time in any other way. Emailing friends for recommendations would have required an email exchange. Posting on job boards would have cost money. Using Elance or oDesk would have been a pain in its own right. Only Twitter allowed me a direct one-to-one correspondence immediately with interested people whom I could quickly vet.

The post Hiring a Freelance Developer Via Twitter and Why This is So Powerful appeared first on Treehouse Blog.

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)