We in the USA are lucky.

Over two centuries we have developed a rule of law that values the civil rights and liberties of our citizens.

True, there’s room for improvement…

We have yet to pass the Equal Rights Amendment, remove social and political barriers associated with gender transgression, resolve de facto racial discrimination, and detach ourselves from patriarchal norms.

But there is a continued progress around the country to address these hanging social inequalities.

Other countries are not as fortunate.

While we have a judicial system to protect and defend our rights…these women do not…

The shocking images before you are of three women who were doused in acid as punishment for turning down proposals and undesired arranged marriages.

In Western cultures, there is a consensus that arranged marriages are not natural and that couples should elope for emotionally driven reasons, such as love and passion.

Unfortunately, these women are long past worrying about matters of the heart.

To some of them, marriage is another burden and societal pressure.  Defying this deeply ingrained tradition could mean life or death.

The practice seems to western eyes primitive and unjust. But what are we to do?

It is hard to convince other societies to change their ways when there are large cultural differences to factor.

What is to some people a barbaric offence (the attacks above, or the death penalty in the US) is to others a proper form of punishment.

There are good non-governmental organizations trying to draw attention to these and other human rights abuses around the globe. But what should our government role in fighting for human rights?

The US has, at times put human rights at the center of its foreign policy. Unfortunately, with the detention center at Quantanamo Bay, accusations of torture and the atrocites at Abu Ghraib prison in Iraq, our human rights’ reputation around the globe has taken a hit.

Being good buddies with questionable human rights regimes in Saudi Arabia and Egypt also doesn’t help the resumé.

Still… we would like to hope that our government would continue to work hard toward stopping the kind of abuse witnessed above.  

By continuing to fight for human rights here and abroad we can, over time, help inspire, educate, and finally instill faith into cultures where abuses often go unpunished.

What do you think we and our government should be doing in the fight for human rights?

Hometown: Baltimore, Maryland, USA

Alma Mater:  University of Baltimore

The task runner Gulp.js is getting more and more popular lately. It can be used for many things, like concatenating JavaScript files or minifying images. If you are new to Gulp.js, I recommend you to start off with Managing Your Build Tasks With Gulp.js. 

In this tutorial, you will learn how to use Gulp.js, in order to run a local web server with built-in, livereload support.

The Old Way

Let's assume we want to develop a single page application. The entry point for this app is a simple index.html file. Our goal is to access this file through the browser, by going to localhost. In the past, perhaps you setup an Apache or Nginx server. Well, that's not needed anymore.

A Better Way

Today, an implementation in JavaScript exists for almost everything, even for a web server. The most popular one is called Connect. We will be using it, by utilizing a Gulp.js plugin called gulp-connect. 

In the following sections, we will setup a local web server for a single page application, so I'll assume you have already setup the basic files, like the gulpfile.js file.

Initial Setup

We start off by installing the Connect plugin with the command below. Everything we need will be installed with this single command.

npm install --save-dev gulp-connect

Tip: npm install --save-dev can be abbreviated with npm i -D.

Now, let's define a task for the web server. Our gulpfile.js should then look like this:

var gulp = require('gulp'),
      connect = require('gulp-connect');
    
    gulp.task('webserver', function() {
      connect.server();
    });
    
    gulp.task('default', ['webserver']);

We can now start the web server by simply running gulp in the terminal. We can open up localhost:8080 in our browser, where we should see index.html. The web server mounts the file structure of the folder, where the gulpfile.js lives in, to the root of localhost:8080. The server will run until you stop the task by pressing Ctrl + c on your keyboard. Great!

You can find the source code for this and all following examples on Github. Each example contains all necessary files to reproduce a working setup. You just need to run npm install in the respective directory.

Adding livereload Support

Setting up the basic web server was easy, right? So let's continue to get livereload running. We need to do two things: first tell the web server to start with livereload support and secondly, we tell livereload when to refresh the page with new content.

The first step is simple. Just set the livereload property to true. The webserver task then looks like this:

gulp.task('webserver', function() {
      connect.server({
        livereload: true
      });
    });

The second step depends on your use case. In this example, we will setup automatic compilation of LESS files to a CSS stylesheet and inject it into the browser. Let's break down this example into its parts. We need a "watcher", which checks if some LESS files got changed. This watcher should then trigger the LESS compiler, which outputs a CSS file. This CSS file should then be injected via livereload.

For this example, we will use the gulp-less plugin. You can install it by running npm install --save-dev gulp-less. The watcher comes already shipped with Gulp.js. Our app file structure should roughly look like this:

.
    ├── node_modules
    │   └── ...
    ├── styles
    │   └── main.less
    ├── gulpfile.js
    ├── index.html
    └── package.json

In the watch task, Gulp.js listens for changes in all *.less files in the styles folder and triggers the less task. Here, the main.less file is the entry point for LESS. After each compile step, the result will be automatically injected into the browser. The code for the gulpfile.js looks like the following, feel free to copy and paste it, to your project.

var gulp = require('gulp'),
      connect = require('gulp-connect'),
      less = require('gulp-less');
    
    gulp.task('webserver', function() {
      connect.server({
        livereload: true
      });
    });
    
    gulp.task('less', function() {
      gulp.src('styles/main.less')
        .pipe(less())
        .pipe(gulp.dest('styles'))
        .pipe(connect.reload());
    });
    
    gulp.task('watch', function() {
        gulp.watch('styles/*.less', ['less']);
    })
    
    gulp.task('default', ['less', 'webserver', 'watch']);

Let's rerun gulp in the terminal and open up again localhost:8080 in the browser. We can now make some changes to a LESS file in the styles folder. It will be instantly compiled and refreshed in the browser. Note that you don't need any browser extensions. livereload works out of the box.

A Few Adjustments

Please keep in mind that the previous gulpfile.js is just a minimal demonstration of how to use Gulp.js as a web server with livereload. I highly recommend playing around with some other plugins. You should also try to rearrange the task structure and use the non-builtin gulp-watch plugin, which allows you to process just the changed files. This becomes important if you're working with a bigger code base. Later in this tutorial, we will see what an alternative task structure might look like.

Changing the Hostname & Port

The gulp-connect plugin itself has many configuration options. For example, you can modify the web server port or hostname. You can even use a custom hostname with port 80 (default is localhost:8080).

connect.server({
      port: 80,
      host: 'gulp.dev'
    });

To get this working, we need to have gulp.dev in our hosts file and run the command sudo gulp. Administrator rights are needed in order to use port 80.

Some Advanced Features

You can go even further using the connect plugin for spawning multiple web servers at the same time. This becomes useful, for example, if you want to run a development web server and run integration tests, simultaneously.

gulp-connect also provides the possibility to use several directories as a root folder. For example, when you're using CoffeeScript and you want to save the compiled JavaScript files in a temporary folder, you can then mount this folder without polluting your source folder.

For more examples, please checkout the GitHub repository.

Refactoring Our Code

In the previous example we setup a minimal gulpfile.js to compile LESS files to CSS and inject them immediately into the browser. It worked, but we can do better. It might be problematic that we mixed the compile and livereload steps into one task. So, let's split them up and watch for changes in the generated files. For that, we will be using the previously mentioned gulp-watch plugin.

Let's go even a step further and add a CoffeeScript compile step. With this additional step, the new structure should be more clear. We install the new plugins in one batch via:

npm install --save-dev gulp-watch gulp-coffee 

And require them in the top of our gulpfile.js. In the following setup, I assume you already have some .coffee files in a directory called scripts. For an example setup, please checkout this repo. The refactored gulpfile.js could look like the following. We'll go through the changes, step by step.

var gulp = require('gulp'),
      connect = require('gulp-connect'),
      watch = require('gulp-watch'),
      less = require('gulp-less'),
      coffee = require('gulp-coffee');
    
    gulp.task('webserver', function() {
      connect.server({
        livereload: true,
        root: ['.', '.tmp']
      });
    });
    
    gulp.task('livereload', function() {
      gulp.src(['.tmp/styles/*.css', '.tmp/scripts/*.js'])
        .pipe(watch())
        .pipe(connect.reload());
    });
    
    gulp.task('less', function() {
      gulp.src('styles/main.less')
        .pipe(less())
        .pipe(gulp.dest('.tmp/styles'));
    });
    
    gulp.task('coffee', function() {
      gulp.src('scripts/*.coffee')
        .pipe(coffee())
        .pipe(gulp.dest('.tmp/scripts'));
    });
    
    gulp.task('watch', function() {
      gulp.watch('styles/*.less', ['less']);
      gulp.watch('scripts/*.coffee', ['coffee']);
    })
    
    gulp.task('default', ['less', 'coffee', 'webserver', 'livereload', 'watch']);

The biggest change we see is the additional livereload task. This task just watches (via the gulp-watch plugin) for changes in the compiled files and refreshes them in the browser. The custom watch() function allows us to just reload the changed files, whereas the built-in gulp.watch() command would reload all files and not just the changed ones.

Because of this single additional task, we don't need a .pipe(connect.reload()) command after each compile step. So we separated the tasks by their concerns, which is always a good idea in software development.

We also noticed that the compiled files aren't saved in their respective source folder any more. They are now stored in a temporary folder named .tmp. The contents of this folder are just generated files and won't pollute the styles or scripts directories any longer. It's also recommended to exclude this folder from your revision control system. All we have to do to get this working, is to also mount .tmp as a root folder, which is done by

root: ['.', '.tmp']

This refactored setup should work just like the one before. But it's way cleaner and easier to extend.

Conclusion

You've just learned how to use Gulp.js as a web server. 

You can combine this technique with many other use cases, like testing or building your single page application. Note that this web server is just meant for local development. For production purposes, you should use a more performant solution like Nginx or a CDN. 

Notice that all the presented features are also possible with Grunt or similar projects. Gulp.js just provides a very simple and elegant way of doing things.

We are conducting interviews with graduating leaders to share their stories and inspire UMBC students for years to come. We can inspire others to enact and lead progress towards a more sustainable society.

1. In what ways were you involved in Sustainability efforts on campus during your time as a student?

I first heard about the Biodiesel club during the spring semester of my second year at UMBC. I was inspired by the club’s mission to generate energy from waste and took over the initiative that following summer. In order to teach myself and others more about biodiesel, I constructed a lab-scale reactor designed to produce a small quantity of biodiesel from waste vegetable oil.

The following semester, I was honored to be one of four students to receive an SGA sustainability intern position. This work experience helped me make connections with like-minded faculty and staff at UMBC and beyond. Throughout the academic year, the other interns and I worked together to bring about sustainable change, including single stream recycling, composting, and most importantly, heightened awareness from the UMBC community.

2. What compelled you be involved? What did you get out of the experiences?

Prior to engaging in sustainable efforts at UMBC, I had an eye-opening experience in the chemical industry. The summer after my first year at UMBC, I accepted a sustainability intern position at global chemical company. The main objective of this position was to quantify waste generated by a number of chemical plants, and the results were quite shocking. In comparison to other countries, the United States consistently generated more waste! From the beginning of my undergraduate chemical engineering career, I vowed to work toward achieving more sustainable practices. It was not long after this experience that I became more involved in sustainable efforts at UMBC.

3. What changes have you seen take place during your time at UMBC?

Recycling has improved drastically since my beginnings with UMBC sustainability. It is much more available throughout campus compared to in the past. The composting initiative was also brought to fruition soon after my gig as a sustainability intern ended. Overall, the UMBC community has become much more aware and compliant with sustainable efforts, thanks to the students’ collective voice and faculty support. Organizations like SGA and SEA in conjunction with the Climate Change Task Force have pushed forward more sustainable efforts in record time.

4. What is your vision for the state of sustainability at UMBC 5 years from now?

I am impressed with the UMBC community’s response thus far to calls for more sustainable practices. It is my hope that the community not only maintains, but increases its level of awareness and sustainable practice for years to come. It is encouraging to see new sustainable ideas and approaches capturing the attention of the community as my final days at UMBC draw near.

5. What are the most important lessons you’ve learned through your work and efforts that you wish to share with UMBC students?

Persistence is the key. There were many times that I was forced to reevaluate my sustainable goals. I was very discouraged the first few times this happened, but then I realized that each and every change in plans added a new level of resilience and “sustainability” to my original goal.

Don’t be afraid to voice your opinion – to anybody. In my early days as an SGA intern, I was terrified to truly state my opinion to faculty, staff, and advisors. However, as I watched fellow interns speak boldly, I noticed that their opinions were truly received. Over time, I gained the confidence to speak firmly and with respect. My words took me to places that I never dreamed I could go.

Laura is graduating with a major in Biochemical Engineering. She is also part of the Honors College and UMBC Cross Country/Track and Field. Thank you, Laura.

Video clip of Laura in the Biodiesel Club

Digital fabrication company brings advanced manufacturing to UMBC

Company is the third digital fabrication lab in Baltimore County

The following is a guest post by Julian Shapiro. Julian recently released Velocity.js, a more performant jQuery replacement for .animate(). He recently wrote about how JavaScript animations can be so fast over on David Walsh's blog, a topic we've covered here as well. In this article, Julian introduces Velocity.js itself.

Velocity.js is a jQuery plugin that re-implements jQuery's $.animate() function to produce significantly higher performance (making Velocity also faster than CSS transitions in many cases) while including several new features to improve animation workflow.

In 7Kb (zipped), Velocity includes all of $.animate()'s features while also packing in transform animation, looping, class animation, and scrolling. In short, Velocity is designed to be the best of jQuery, jQuery UI, and CSS transitions.

Velocity works everywhere — back to IE8 and Android 2.3. Further, since Velocity's syntax is identical to $.animate()'s, none of your page's code needs to change.

The goal of Velocity is to be a leader in DOM animation performance and convenience. This article focuses on the latter. To learn more about the former, refer to Velocity's performance comparisons over at VelocityJS.org. In particular, this article demonstrates how to use Velocity to improve your UI animation workflow. In a concise showdown, eight of Velocity's features are compared against their jQuery counterparts.

If you feel that your current UI workflow is messy, poorly segregated, or too reliant upon jQuery’s broad array of style functions, then this walkthrough is for you.

Brief Overview

Before we dive into Velocity, let's quickly cover the bases: It should be pointed out that both $.animate() and $.velocity() support a malleable options syntax. You can either pass in options as comma-separated values, or you can pass in a standalone options object.

Here's an example of the comma-separated syntax, in which an integer is treated as the animation's duration, a string is treated as the easing type, and a function is treated as a callback (which is triggered upon the animation's completion):

$div.animate(
      { 
        opacity: 1 
      }, 
      1000, 
      "linear", 
      function() { 
        alert("Done animating."); 
      }
    );

Next, here's an example of the object syntax:

$div.animate(
      { 
        opacity: 1 
      }, 
      { 
        duration: 1000, 
        easing: "linear", 
        complete: function() { 
          alert("Done animating!") 
        }, 
        queue: "myQueue" 
      }
    );

Beyond producing cleaner-looking code, using the options object provides access to additional animation parameters that are otherwise not able to be specified via the comma-separated syntax.

An example of one such option provided by jQuery is "queue". Velocity also provides the queue option, and multiple animation calls chained onto a single element automatically queue onto one another.

Here, a div's opacity will be animated to 1 for 1000ms then back down to 0 for the next 1000ms:

$div
      .animate({ opacity: 1 }, 1000)
      .animate({ opacity: 0 }, 1000);

Now, with the bases out of the way, let's start comparing Velocity to jQuery.

Reversing

In place of a properties map, Velocity also accepts "reverse" as its first parameter. Reverse animates the target element toward its values prior to its previous Velocity call.

In jQuery, that would be like:

$div
      /* Fade an element in while sliding it into view. */
      .animate({ opacity: 1, top: "50%" })
      /* The values below are what we originally set the element to in our stylesheet. Animate back to them. */ 
      .animate({ opacity: 0, top: "-25%" });

In Velocity, it's easier as it is not only less code, but you don't have to repeat values from your stylesheet:

$div
      .velocity({ opacity: 1, top: "50%" })
      .velocity("reverse");

By default, Velocity's reverse command uses the same options that were passed into the previous Velocity call. These options can be extended by passing new options into the "reverse" call. For example:

$div
      .velocity({ opacity: 1, top: "50%" }, 1000)
      /* Animate back to the prior visual state at half the duration of the previous animation. */
      .velocity("reverse", 500);

Scrolling

A popular UI technique is to scroll the browser so that it's aligned with an element further down the page, then to animate that element with attention-grabbing flourishes. Pulling this off with jQuery involves messy, non-performant code:

In jQuery, animating the scrollTop property requires you to target both the html element and the body element in order for the animation to work in older versions of Internet Explorer.

$("html, body").animate(
      { 
        scrollTop: $div.offset().top 
      }, 
      1000, 
      function() {
        /* We use a callback to fade in the div once the browser has completed scrolling. */
        $div.animate({ opacity: 1 });
      }
    );

In Velocity, you target the element you want to scroll to:

$div
      .velocity("scroll", 1000)
      .velocity({ opacity: 1 });

Just as with Velocity's "reverse" command, "scroll" can be passed in as Velocity's first parameter in place of a properties map. Also like the reverse command, the scroll command accepts animation options and can be chained onto other calls.

The scroll command's behavior is straightforward: Scroll the browser to the top of the element targeted by the Velocity call.

Looping

Oftentimes, an element's animation needs to be looped. Examples include shaking a dialog box to indicate invalid user input or bouncing a notification icon to grab the user's attention.

In jQuery, looping an animation entails messing your animation logic by breaking part of it out into a for statement:

for (var i = 0; i < 5; i++) {
      $div
        /* Slide the element up by 100px. */
        .animate({ top: -100 })
        /* Then animate back to the original value. */
        .animate({ top: 0 });
    }

In Velocity, simply set the loop option to an integer equal to the desired number of loop cycles. A single loop cycle consists of animating toward the values in the property map followed by reversing back to the original values.

$div.velocity(
      { top: -100 }, 
      { loop: 5 }
    );

Fading Elements

You'll often find yourself fading in an element whose display property was initially set to none, so that the element wasn't immediately visible upon page load. Subsequently fading in these elements requires several lines of jQuery:

$div
      /* Use jQuery's $.show() function to make the element visible by switching its display property to "block"/"inline" as appropriate. */
      .show()
      /* Set the element's starting opacity to 0 so that it can be gradually faded in by the subsequent animation call. */
      .css("opacity", 0)
      /* Fade in and slide into view. */
      .animate({ 
        opacity: 1, 
        top: "50%" 
      });

In Velocity, you simply pass in display as an option. The display option accepts the same set of values that its CSS property counterpart does (e.g. "block", "inline", and "none").

$div.velocity(
      { 
        opacity: 1, 
        top: "50%" 
      },
      { 
        display: "block" 
      }
    );

When the display option is set to a value other than none, the element's display property is set to the provided value at the start of the animation. Conversely, when display is passed a value of none, the display property is set upon the animation's completion.

$div
      /* Fade out and slide out of view. */
      .animate({ opacity: 0, top: "-50%" })
      /* Then set the display property to "none" via a queued $.fadeOut() call. */
      .fadeOut(1);

$div.velocity(
      { 
        opacity: 0,
        top: "-50%" 
      }, 
      { 
        display: "none" 
      }
    );

Further, if an element's opacity is being animated to a non-zero value while its display option is being set to a value other than none, Velocity conveniently defaults opacity's start value to 0.

Delaying

Velocity accepts a delay option that replaces having to sprinkle $.delay() calls throughout your animation code:

$div
      .delay(1000)
      .animate({ 
        opacity: 1 
      });

$div.velocity(
      { 
        opacity: 1 
      }, 
      { 
        delay: 1000 
      }
    );

Beyond consolidating animation logic into a single call, using Velocity's built-in delay option allows Velocity to optimize chained animations by caching values between them.

Class Animation

This article used to have a bit about class animations (e.g. animating the properties from one class, as defined in CSS, to another). It has been removed, at the request of Julian, as it has been replaced in the library with the more powerful Sequences feature.

Forced Hardware Acceleration

Forcing hardware acceleration (HA) on an element is an easy to way to dramatically increase animation performance on mobile devices. Enabling HA is traditionally achieved by setting an element's transform property to translateZ(0).

$div
      .css("transform", "translateZ(0)")
      .animate({ opacity: 1 })
      .css("transform", "none");

In Velocity, HA is automatically applied on mobile devices (there's no performance boost to be gained on the desktop). Velocity's control over HA is highly optimized.

$div.velocity({ opacity: 1 });

Wrapping Up

The purpose of this walkthrough has been to demonstrate Velocity's consolidation of animation logic within your code. In short, Velocity is an expressive and efficient tool for crafting UI animations.

While jQuery is tremendously powerful, it was never jQuery's design goal to function as an optimized animation engine, and it suffers accordingly from less-than-ideal performance and workflows. At just 7Kb zipped, Velocity packs in enough features and speed gains for you to consider making it your animation engine of choice.

To explore the remainder of Velocity's features, including color and transform animation, check out Velocity's documentation at VelocityJS.org.

Before we conclude, here are some extreme examples of web animation that are made possible through the expressiveness and speed of Velocity:

• 3D demo
• Virtual world demo
• HUD demo
• Multimedia demo

Improving UI Animation Workflow with Velocity.js is a post from CSS-Tricks