The elections for both the IEEE Undergraduate Student Branch and IEEE Graduate Student Branch Executive Boards have been scheduled for Friday, April 19th, 4.00pm to 5.00pm, room TBA. This is our regular meeting time. Below you will find more information on the election process, including the procedure to run for an Officer position.

IEEE Undergraduate Student Branch Officer positions include the following.

• Chair: Will be responsible for leading the IEEE Undergraduate Student Branch overall. S/he will also be responsible for representing the IEEE USB in General Body meetings and Executive Board meetings, and delegating responsibilities for various task. Events and activities must be approved by the Chair before sent to committees and funds must be approved before being forwarded to the Treasurer.
• Vice-Chair: Will be responsible for assisting the Chair in leading the IEEE USB and helping to run the branch smoothly. If the Chair is not present, the VP will take upon her/his responsibilities.
• Secretary: Will be responsible for taking minutes at meetings, keeping track of undergraduate student attendance and reporting the activities to the branch. S/he will be the point person for external relationships.
• Treasurer: Will manage the accounts and funds for the IEEE USB. S/he’ll be responsible for attending the SGA treasurer training session, and working with the Executive Board to generate a budget plan.
• Member At Large: Will support the other executive board members by facilitating their responsibilities as well as managing member recruitment/retention, managing fundraising activities in cooperation with the Treasurer and developing and managing projects.

IEEE Graduate Student Branch Officer positions include the following.

• Chair: Will be responsible for leading the IEEE Graduate Student Branch overall. S/he will also be responsible for representing the GSO in the GSA Senate meetings and external events. Funds must be approved by the Chair before being forwarded to the Treasurer.
• Vice-Chair: Will be responsible for assisting the Chair in leading the IEEE GSB and helping her/him to run the branch smoothly.
• General Secretary: Will be responsible for reporting the activities to the IEEE SB GSA. S/he will be the point person for external relationships.
• Treasurer: Will manage the accounts and funds for the IEEE GSB. S/he’ll be responsible for the annual budget report along with the payments.

To run for one of the above positions you must be a grad/undergrad student in good academic status, be subscribed to our mailing list, and send me (Sorry, you need javascript to view this email address. ) a small description (no more than 100 words) about you and why should other members vote for you, no later than next Thursday, April 11th, by 12.00pm (noon). You can only run for one position.

These descriptions will be compiled and sent out to the entire mailing list no later than the following Friday, April 12th. Each candidate will be given two minutes during that Friday's meeting to make a brief speech.

The election process will be supervised by our advisor, Dr. Choa.

IMPORTANT

• if you win, you MUST be an official IEEE member or become one within a week after the election date.
• to vote, you must present your UMBC ID and the email that you used to subscribe to our mailing list.

Please come and vote on the 19th to ensure that your voice is heard, and consider running for one of the positions. If you have any concerns or questions about the election process, please let Jorge Teixeira (Sorry, you need javascript to view this email address. ) know ASAP.

On behalf of the UMBC IEEE GSB and UMBC IEEE USB Executive Boards,

UMBC IEEE Student Branch, Chair
Jorge Teixeira

A new Washington Times commentary critiquing government contracting programs for minority- and women-owned firms references testimony by UMBC professor George La Noue on why federal contacting preferences should be reexamined. La Noue is an expert on education policy, constitutional law and policy, and public procurement policy, and is a frequent witness in Congressional testimony.

Nicole Else-Quest, assistant professor of psychology, is the author of an April 9 post in the “Huffington Post” blog entitled “Contextualizing the Conversation on Women and STEM.”

Else-Quest is the lead author of a recent study that found that female students perform as well as males in STEM classrooms, but report less confidence about their abilities.  It also found that Asian American students outperform other ethnic groups.

In her piece for the Huffington Post, she argued that “the national conversation about women and STEM cannot progress until it considers gender within the context of other social identity variables, such as ethnicity, class, and immigration.”

“We don’t think of ourselves as only having gender or only having race. We think of ourselves as multifaceted and complex individuals – because we are multifaceted and complex individuals,” she writes.

Every so often, we’ll chat with an alum about what they do and how they got there. Today, in honor of National Poetry Month, we’re talking with English teacher and poet Jackie (Vreatt) Regales ’00, American studies, who spends much of the day sharing her love of the written word with the next generation…

Name: Jackie (Vreatt) Regales ’00, American studies
Job: English teacher at Roland Park Country School
Website: A Patchwork Life: Writing, Teaching, and Piecing it all Together

Q:  Tell us a little about why you decided to get into education.

A:  My mother taught high school for 38 years (I even had her for AP U.S. History!), and I always said I wouldn’t go into teaching because I saw how hard she worked, and how difficult her job really was. But then as a senior [at UMBC], I had the chance to be a teaching assistant for Dr. Pat McDermott, who is now a Vice Provost, but was then in the American Studies department. I led a few discussions and activities in her class that semester, and it was such an amazing experience that I knew I had to follow this path further. I went to graduate school on a teaching assistantship, and knew for certain that teaching was the right career for me.

Q:  What do you love most about teaching? What do you find most challenging?

A:  The best moments in my job are when I get to see students fall in love with a book, a book that either changes how they see the world or makes them feel less alone in the world, books like The Great Gatsby or The Catcher in the Rye, both of which I disliked when I first read them, but now adore after getting to teach them. I also feel so fulfilled when a student who previously didn’t like reading or felt like a terrible writer makes leaps and bounds of progress and feels so much more skilled and confident at the end of the year.

What do I find challenging about teaching? Personally, I find that teaching is the kind of job that can suck up every possible minute you let it; there’s always grading to do, or lessons that could be better, new books to consider or research that promises to finally help kids understand grammar better. I know we get the summers off, which I definitely value, but most teachers I know are working way more than forty hours a week during the school year, and many spend summer hours trying to develop themselves more as professionals.

Another challenge is how invested we come to feel in the lives of our students and families, and how vulnerable that makes us. Every teacher has a story about the kid they couldn’t reach or save, the family that broke apart in violent ways and the girl or boy caught in the middle, the realization that we can’t make a kid hear something they aren’t ready to understand yet about themselves. High school kids can really break your heart, and each year, we open ourselves up to a new wave of them!

Q:  You’ve even come back to teach at UMBC, right? What did you teach, and how did it feel to be teaching at your alma mater?

A:  I did! After I earned my master’s degree, I was doing some adjunct teaching when Jason Loviglio offered me a few classes in the newly developing Media and Communication Studies program. I taught a 300-level elective on “Facebook Culture,” as well as a 300-level course for students in the major, and assisted Donald Snyder with the capstone research seminar. This was a wonderful opportunity for me, and certainly the best adjunct experience I ever had! As far as teaching at my alma mater, I loved it; intellectually, it was exciting to have the freedom to develop these courses, and Jason and Donald were welcoming and supportive mentor figures. I definitely put some pressure on myself to succeed so that Jason’s faith in me would be rewarded, because he was an influential professor for me as a student as well.

Q:  You’re also a poet. How do you keep yourself going, creatively, and how do you instill the love of poetry in your students?

A:  One of my assets as a writer has been surrounding myself with encouraging resources. My husband has always my biggest fan, and I’m also lucky to have Seth Sawyers ’99, history, a writer friend in my life I can ask for feedback; we actually met when we were both tutors at the Writing Center at UMBC. As far as keeping going creatively, the wisest decision I made was to let go of any pretenses about what I needed in order to write: a room of my own, uninterrupted spans of time, the structure of a formal writing program, unlimited childcare, a personal chef or housekeeper, etc. I would still love to have some or all of those things at some point in my life, but what I realized is that I don’t need them—what I need is to write, to make some space in my life whenever possible to get the words down onto the page. Writing is part of how I process the world, and is integrally part of how I approach my life. Therefore, postponing writing until I had more time, money, peace, whatever was never really an option, so I learned how to weave it through my life as best I could.

One of my favorite ways to help my students love poetry is to encourage them to simply stay open to it; so many students (and adults!) see poetry as this mysterious and indecipherable code that makes them feel stupid or ignorant. During National Poetry Month, I give my students extra credit for public poetry projects on campus; they choose poems, I approve them, and then they do something public to introduce that poem to our community. This year I’ve got students eager to read poems with first-graders, make bulletin board displays of Russian poetry and decorate our campus bathrooms with Maya Angelou’s “Phenomenal Woman” to help encourage self-esteem in their classmates. Explicating poetry is a valuable skill, but I also want to surprise students into finding something valuable and beautiful in poetry without necessarily understanding anaphora or trochaic tetrameter.

Q:  Tell us about some of your writing projects!

A:  Right now, I’m part of an exciting project involving found poetry, which is basically the literary equivalent of a collage, taking words and phrases from existing texts and using them to form and inspire new pieces of writing. I’m one of 85 participating poets in the Pulitzer Remix project, sponsored by The Found Poetry Review. Each poet was assigned a book that has won the Pulitzer Prize for literature, and each day during National Poetry Month, we are writing/posting poems we created from the text of our prize winner. By the end of the project, we will have created over 2500 found poems! I have participated in poetry month challenges for the past few years, writing a new poem each day in April based on various prompts, but this has been a big leap of faith for me, and it’s been invigorating and inspiring to challenge myself in this way.

Q: In honor of National Poetry Month, what poet/poem would you like to share with your UMBC alumni friends, and why?

A:  One of my favorite poets is Pablo Neruda; his work is clear, simple, powerful and beautiful, rich with metaphors and similes, with such range and passion that it’s difficult to resist. He was a deeply political poet in many ways, and wrote movingly about the landscape of his native Chile, but it’s his love poetry that really makes me swoon. Try “I can write the saddest verses,” “I like it when you’re quiet,” or my absolute favorite, “I don’t love you as if you were a rose” and see if you don’t get a little smitten with Neruda too.

The concept of Aspect-Oriented Programming (AOP) is fairly new to PHP. There’s currently no official AOP support in PHP, but there are some extensions and libraries which implement this feature. In this lesson, we’ll use the Go! PHP library to learn AOP in PHP, and review when it can be helpful.

A Brief History of AOP

Aspect-Oriented programming is like a new gadget for geeks.

The term Aspect-Oriented Programming took shape in the mid-1990s, inside a small group at Xerox Palo Alto Research Center (PARC). AOP was considered controversial in its early days — as is the case with any new and interesting technology — mostly due to its lack of clear definition. The group made the conscious decision to release it in a half-baked form, in order to let the larger community provide feedback. At the heart of the problem was the “Separation of Concerns” concept. AOP was one possible solution to separate concerns.

AOP matured in the late 1990s, when Xerox released AspectJ, and IBM followed suit with their Hyper/J in 2001. Today, AOP is a well-established technology that has been adopted by most common programming languages.

The Basic Vocabulary

At the heart of AOP is the aspect, but before we can define “aspect,” we must discuss two other terms: point-cut and advise. A point-cut represents a moment in our source code, specifying the right moment to run our code. The code that executes at a point-cut is called, advise, and the combination of one or more point-cuts and advises is the aspect.

Typically, each class has one core behavior or concern, but in many situations, a class may exhibit secondary behavior. For example, a class may need to call a logger or notify an observer. Because these functionalities are secondary, their behavior is mostly the same for all the classes that exhibit them. This scenario is called a cross-concern; these can be avoided by using AOP.

The Various AOP Tools for PHP

Chris Peters already discussed the Flow framework for AOP in PHP. Another AOP implementation can be found in the Lithium framework.

Another framework took a different approach, and created a complete PHP extension in C/C++, performing its magic on the same level as the PHP interpreter. It is called the AOP PHP Extension, and I may discuss it in a future article.

But as I noted earlier, for this tutorial, we’ll review the Go! AOP-PHP library.

Installing and Preparing Go!

The Go! library is not an extension; it’s completely written in PHP for PHP 5.4 and higher. Being just a plain PHP library allows for easy deployment, even in restrictive, shared-hosting environments that do not allow you to compile and install your own PHP extensions.

Install Go! with Composer

Composer is the preferred method for installing PHP packages. If you do not have access to Composer, you can always download it from the Go! GitHub repository.

First, add the following lines to your composer.json file.

{
        "require": {
            "lisachenko/go-aop-php": "*"
        }
    }

Next, use Composer to install go-aop-php. Run the following command from a terminal:

$ cd /your/project/folder
    $ php composer.phar update lisachenko/go-aop-php

Composer will install the required packages and dependencies in just a few seconds. If successful, you should see something similar to the following output:

Loading composer repositories with package information
    Updating dependencies
      - Installing doctrine/common (2.3.0)
        Downloading: 100%
    
      - Installing andrewsville/php-token-reflection (1.3.1)
        Downloading: 100%
    
      - Installing lisachenko/go-aop-php (0.1.1)
        Downloading: 100%
    
    Writing lock file
    Generating autoload files

After the installation has completed, you will find a directory, called vendor, in your source folder. The Go! library and its dependencies are installed there.

$ ls -l ./vendor
    total 20
    drwxr-xr-x 3 csaba csaba 4096 Feb  2 12:16 andrewsville
    -rw-r--r-- 1 csaba csaba  182 Feb  2 12:18 autoload.php
    drwxr-xr-x 2 csaba csaba 4096 Feb  2 12:16 composer
    drwxr-xr-x 3 csaba csaba 4096 Feb  2 12:16 doctrine
    drwxr-xr-x 3 csaba csaba 4096 Feb  2 12:16 lisachenko
    
    $ ls -l ./vendor/lisachenko/
    total 4
    drwxr-xr-x 5 csaba csaba 4096 Feb  2 12:16 go-aop-php
    

Integrate Go! Into Our Project

We need to create a call that sits between the routing/entry point of our application. The autoloader then automatically includes the class. Go! refers to this as an Aspect Kernel.

use Go\Core\AspectKernel;
    use Go\Core\AspectContainer;
    
    class ApplicationAspectKernel extends AspectKernel {
    
    	protected function configureAop(AspectContainer $container) {
    
    	}
    
    	protected function getApplicationLoaderPath() {
    
    	}
    
    }

Today, AOP is a well-established technology that has been adopted by most common programming languages.

For this example, I’ve created a directory, called Application, and added a new class file, ApplicationAspectKernel.php within it.

Our aspect kernel extends Go!’s abstract AspectKernel class, which provides the basic functionality that the aspect kernel requires to do its job. There are two methods we must implement: configureAop(), which registers our future aspects, and getApplicationLoaderPath(), which provides a string representing the full path to the application’s autoloader.

For now, simply create an empty autoload.php file in your Application directory, and change the getApplicationLoaderPath() method, accordingly.

// [...]
    class ApplicationAspectKernel extends AspectKernel {
    
    	// [...]
    
    	protected function getApplicationLoaderPath() {
    		return __DIR__ . DIRECTORY_SEPARATOR . 'autoload.php';
    	}
    
    }

Don’t worry about autoload.php just yet; we’ll fill in the missing pieces shortly.

When I first installed Go! and reached this point of my process, I felt the need to run some code. So let’s begin building a small application!

Creating A Simple Logger

Our aspect will be a simple logger, but we first need some code to watch before we start with the main portion of our application.

Create A Minimal Application

Our small application will be an electronic broker, capable of buying and selling shares.

class Broker {
    
    	private $name;
    	private $id;
    
    	function __construct($name, $id) {
    		$this->name = $name;
    		$this->id = $id;
    	}
    
    	function buy($symbol, $volume, $price) {
    		return $volume * $price;
    	}
    
    	function sell($symbol, $volume, $price) {
    		return $volume * $price;
    	}
    
    }

This code is quite simple. The Broker class has two private fields that store the broker’s name and ID.

This class also offers two methods, buy() and sell() for buying and selling shares, respectively. Each of these methods accepts three arguments: the share’s symbol, the number of shares, and the price per share. The sell() method sells the shares and then calculates the total money received. Conversely, the buy() method buys the shares and calculates the total money spent.

Exercise Our Broker

We can easily exercise our Broker by writing a PHPUnit test. Create a directory, called Test inside the Application directory, and, within it, add a new file, BrokerTest.php. Append the following code to that file:

require_once '../Broker.php';
    
    class BrokerTest extends PHPUnit_Framework_TestCase {
    
    	function testBrokerCanBuyShares() {
    		$broker = new Broker('John', '1');
    		$this->assertEquals(500, $broker->buy('GOOGL', 100, 5));
    	}
    
    	function testBrokerCanSellShares() {
    		$broker = new Broker('John', '1');
    		$this->assertEquals(500, $broker->sell('YAHOO', 50, 10));
    	}
    
    }

This test simply checks the return values of the broker’s methods. We can run this test and see that our code is at least syntactically correct.

Add an Auto Loader

Let’s create an autoloader that physically loads the classes that our application needs. This will be a simple loader, based on the PSR-0 autoloader.

ini_set('display_errors', true);
    
    spl_autoload_register(function($originalClassName) {
        $className = ltrim($originalClassName, '\\');
        $fileName  = '';
        $namespace = '';
        if ($lastNsPos = strripos($className, '\\')) {
            $namespace = substr($className, 0, $lastNsPos);
            $className = substr($className, $lastNsPos + 1);
            $fileName  = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
        }
        $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
    
        $resolvedFileName = stream_resolve_include_path($fileName);
        if ($resolvedFileName) {
            require_once $resolvedFileName;
        }
        return (bool) $resolvedFileName;
    });

That’s all we need for the autoload.php file. Now, change BrokerTest.php to require the autoloader instead of Broker.php class.

require_once '../autoload.php';
    
    class BrokerTest extends PHPUnit_Framework_TestCase {
    	// [...]
    }

Running BrokerTest proves that the code still works.

Connecting to Application Aspect Kernel

Our final step is to configure Go!. We need to connect all the components so that they work in harmony. First, create a file, called AspectKernelLoader.php, and add the following code:

include __DIR__ . '/../vendor/lisachenko/go-aop-php/src/Go/Core/AspectKernel.php';
    include 'ApplicationAspectKernel.php';
    
    ApplicationAspectKernel::getInstance()->init(array(
        'autoload' => array(
            'Go'               => realpath(__DIR__ . '/../vendor/lisachenko/go-aop-php/src/'),
            'TokenReflection'  => realpath(__DIR__ . '/../vendor/andrewsville/php-token-reflection/'),
            'Doctrine\\Common' => realpath(__DIR__ . '/../vendor/doctrine/common/lib/')
        ),
        'appDir' => __DIR__ . '/../Application',
        'cacheDir' => null,
        'includePaths' => array(),
        'debug' => true
    ));

We need to connect all the components so that they work in harmony.

This file sits between the front controller and the autoloader. It uses the AOP infrastructure to initialize and call the autoload.php when needed.

In the first line, we explicitly include AspectKernel.php and ApplicationAspectKernel.php. These files must be explicitly included, because, remember, we have no autoloader at this point.

In the following code segment, we call the init() method on the ApplicationAspectKernel object and pass it an array of options:

• autoload defines the paths to initialize for the AOP library. Adjust the paths according to your directory structure.
• appDir refers to the application’s directory.
• cacheDir specifies a cache directory (we’ll ignore this for this tutorial).
• includePaths represents a filter for the aspects. We want all the specified directories to be watched, so leave this array empty to watch everything.
• debug provides extra debugging information, which is useful for development, but you should set it to false for deployed applications.

To finalize the connection between the different pieces, find all references to autoload.php in your project and replace them with AspectKernelLoader.php. In our simple example, only the test file requires modification:

require_once '../AspectKernelLoader.php';
    
    class BrokerTest extends PHPUnit_Framework_TestCase {
    
    // [...]
    
    }

For bigger projects, you may find that it’s useful to use bootstrap.php for PHPUnit; the require_once() for autoload.php or our AspectKernelLoader.php should be included there.

Log the Broker’s Methods

Create a file, called BrokerAspect.php, and add the following code:

use Go\Aop\Aspect;
    use Go\Aop\Intercept\FieldAccess;
    use Go\Aop\Intercept\MethodInvocation;
    use Go\Lang\Annotation\After;
    use Go\Lang\Annotation\Before;
    use Go\Lang\Annotation\Around;
    use Go\Lang\Annotation\Pointcut;
    use Go\Lang\Annotation\DeclareParents;
    
    class BrokerAspect implements Aspect {
    
    	/**
    	 * @param MethodInvocation $invocation Invocation
    	 * @Before("execution(public Broker->*(*))") // This is our PointCut
    	 */
    	public function beforeMethodExecution(MethodInvocation $invocation) {
    		echo "Entering method " . $invocation->getMethod()->getName() . "()\n";
    	}
    }

We begin by specifying several use statements for the AOP infrastructure. Then, we create our aspect class, called BrokerAspect, which must implement Aspect. Next, we specify the matching logic for our aspect:

* @Before("execution(public Broker->*(*))")

• @Before specifies when to apply the advice. Possibilities are @Before, @After, @Around and @AfterThrowing.
• "execution(public Broker->*(*))" specifies the matching rule as the execution of any public method on a class, called Broker, with any number of parameters. The syntax is: [operation - execution/access]([method/attribute type - public/protected] [class]->[method/attribute]([params])

Please note that the matching mechanism is admittedly somewhat awkward. You can use only one ‘*‘ (star) in each part of the rule. For example, public Broker-> matches a class, called Broker. public Bro*-> matches any class starting with Bro, and public *ker-> matches any class ending with ker.

public *rok*-> will not match anything; you may not use more than one star for the same match.

The method following the matcher will be called when the event occurs. In our case, the method executes before each call on one of Broker‘s public methods. A parameter, called $invocation (of type MethodInvocation), is automatically passed to our method. This object provides different ways of obtaining information about the called method. In this first example, we use it to obtain the method’s name and print it.

Registering The Aspect

Merely defining an aspect is not enough; we need to register it into the AOP infrastructure. Otherwise, it will not be applied. Edit ApplicationAspectKernel.php and call registerAspect() on the container in the configureAop() method:

use Go\Core\AspectKernel;
    use Go\Core\AspectContainer;
    
    class ApplicationAspectKernel extends AspectKernel
    {
    
        protected function getApplicationLoaderPath()
        {
            return __DIR__ . DIRECTORY_SEPARATOR . 'autoload.php';
        }
    
        protected function configureAop(AspectContainer $container)
        {
            $container->registerAspect(new BrokerAspect());
        }
    }

Run the tests and check the output. You should see something similar to the following:

PHPUnit 3.6.11 by Sebastian Bergmann.
    
    .Entering method __construct()
    Entering method buy()
    .Entering method __construct()
    Entering method sell()
    Time: 0 seconds, Memory: 5.50Mb
    
    OK (2 tests, 2 assertions)

So we’ve managed to run code whenever something happens on the broker.

Finding Parameters and Matching @After

Let’s add another method to the BrokerAspect.

// [...]
    class BrokerAspect implements Aspect {
    
    	// [...]
    
    	/**
    	 * @param MethodInvocation $invocation Invocation
    	 * @After("execution(public Broker->*(*))")
    	 */
    	public function afterMethodExecution(MethodInvocation $invocation) {
    		echo "Finished executing method " . $invocation->getMethod()->getName() . "()\n";
    		echo "with parameters: " . implode(', ', $invocation->getArguments()) . ".\n\n";
    	}
    }

This method runs after a public method executes (note the @After matcher). We then add another line to output the parameters used to call the method. The output of our test now is:

PHPUnit 3.6.11 by Sebastian Bergmann.
    
    .Entering method __construct()
    Finished executing method __construct()
    with parameters: John, 1.
    
    Entering method buy()
    Finished executing method buy()
    with parameters: GOOGL, 100, 5.
    
    .Entering method __construct()
    Finished executing method __construct()
    with parameters: John, 1.
    
    Entering method sell()
    Finished executing method sell()
    with parameters: YAHOO, 50, 10.
    
    Time: 0 seconds, Memory: 5.50Mb
    
    OK (2 tests, 2 assertions)

Getting Return Values and Manipulating Execution

So far, we’ve learned how to run extra code before and after a method executes. While this is nice, it’s not overly useful if we can’t see what the methods return. Let’s add another method to the aspect and modify the existing code:

 //[...]
    class BrokerAspect implements Aspect {
    
    	/**
    	 * @param MethodInvocation $invocation Invocation
    	 * @Before("execution(public Broker->*(*))")
    	 */
    	public function beforeMethodExecution(MethodInvocation $invocation) {
    		echo "Entering method " . $invocation->getMethod()->getName() . "()\n";
    		echo "with parameters: " . implode(', ', $invocation->getArguments()) . ".\n";
    	}
    
    	/**
    	 * @param MethodInvocation $invocation Invocation
    	 * @After("execution(public Broker->*(*))")
    	 */
    	public function afterMethodExecution(MethodInvocation $invocation) {
    		echo "Finished executing method " . $invocation->getMethod()->getName() . "()\n\n";
    	}
    
    	/**
    	 * @param MethodInvocation $invocation Invocation
    	 * @Around("execution(public Broker->*(*))")
    	 */
    	public function aroundMethodExecution(MethodInvocation $invocation) {
    		$returned = $invocation->proceed();
    		echo "method returned: " . $returned . "\n";
    
    		return $returned;
    	}
    
    }

Merely defining an aspect is not enough; we need to register it into the AOP infrastructure.

This new code moves the parameter information to the @Before method. We also add another method with the special @Around matcher. This is neat, because the original matched method call is wrapped inside the aroundMethodExecution() function, effectively supressing the original invocation. Inside the advise, we need to call $invocation->proceed(), in order to execute the original call. If you don’t do this, the original call will not occur.

This wrapping also allows us to manipulate the returned value. What we return in our advise is what returns in the original call. In our case, we didn’t change anything, and your output should look like this:

PHPUnit 3.6.11 by Sebastian Bergmann.
    
    .Entering method __construct()
    with parameters: John, 1.
    method returned:
    Finished executing method __construct()
    
    Entering method buy()
    with parameters: GOOGL, 100, 5.
    method returned: 500
    Finished executing method buy()
    
    .Entering method __construct()
    with parameters: John, 1.
    method returned:
    Finished executing method __construct()
    
    Entering method sell()
    with parameters: YAHOO, 50, 10.
    method returned: 500
    Finished executing method sell()
    
    Time: 0 seconds, Memory: 5.75Mb
    
    OK (2 tests, 2 assertions)

Let’s play a little and offer a discount for a specific broker. Return to the test class, and write the following test:

require_once '../AspectKernelLoader.php';
    
    class BrokerTest extends PHPUnit_Framework_TestCase {
    
    	// [...]
    
    	function testBrokerWithId2WillHaveADiscountOnBuyingShares() {
    		$broker = new Broker('Finch', '2');
    		$this->assertEquals(80, $broker->buy('MS', 10, 10));
    	}
    
    }

This will fail with:

Time: 0 seconds, Memory: 6.00Mb
    
    There was 1 failure:
    
    1) BrokerTest::testBrokerWithId2WillHaveADiscountOnBuyingShares
    Failed asserting that 100 matches expected 80.
    
    /home/csaba/Personal/Programming/NetTuts/Aspect Oriented Programming in PHP/Source/Application/Test/BrokerTest.php:19
    /usr/bin/phpunit:46
    
    FAILURES!
    Tests: 3, Assertions: 3, Failures: 1.

Next, we need to modify the broker to provide its ID. Just implement a getId() method, as demonstrated below:

class Broker {
    
    	private $name;
    	private $id;
    
    	function __construct($name, $id) {
    		$this->name = $name;
    		$this->id = $id;
    	}
    
    	function getId() {
    		return $this->id;
    	}
    
    	// [...]
    
    }

Now, modify the aspect to adjust the buying price for a broker with an ID of 2.

 // [...]
    class BrokerAspect implements Aspect {
    
    	// [...]
    
    	/**
    	 * @param MethodInvocation $invocation Invocation
    	 * @Around("execution(public Broker->buy(*))")
    	 */
    	public function aroundMethodExecution(MethodInvocation $invocation) {
    		$returned = $invocation->proceed();
    		$broker = $invocation->getThis();
    
    		if ($broker->getId() == 2) return $returned * 0.80;
    		return $returned;
    	}
    
    }

Instead of adding a new method, just modify the aroundMethodExecution() function. It now only matches methods, called ‘buy‘, and triggers $invocation->getThis(). This effectively returns the original Broker object so that we may execute its code. And so we did! We ask the broker for its ID, and offer a discount if the ID is equal to 2. The test now passes.

PHPUnit 3.6.11 by Sebastian Bergmann.
    
    .Entering method __construct()
    with parameters: John, 1.
    Finished executing method __construct()
    
    Entering method buy()
    with parameters: GOOGL, 100, 5.
    Entering method getId()
    with parameters: .
    Finished executing method getId()
    
    Finished executing method buy()
    
    .Entering method __construct()
    with parameters: John, 1.
    Finished executing method __construct()
    
    Entering method sell()
    with parameters: YAHOO, 50, 10.
    Finished executing method sell()
    
    .Entering method __construct()
    with parameters: Finch, 2.
    Finished executing method __construct()
    
    Entering method buy()
    with parameters: MS, 10, 10.
    Entering method getId()
    with parameters: .
    Finished executing method getId()
    
    Finished executing method buy()
    
    Time: 0 seconds, Memory: 5.75Mb
    
    OK (3 tests, 3 assertions)

Matching Exceptions

We can now execute extra code when a method is entered, after it executes and around it. But what if a method throws an exception?

Add a test method to buy a large number of shares:

function testBuyTooMuch() {
    	$broker = new Broker('Finch', '2');
    	$broker->buy('MS', 10000, 8);
    }

Now, create an exception class. We need this because the built-in Exception class cannot be caught by Go! AOP or PHPUnit.

class SpentTooMuchException extends Exception {
    
    	public function __construct($message) {
    		parent::__construct($message);
    	}
    
    }

Modify the broker to throw an exception for a large value:

class Broker {
    
    	// [...]
    
    	function buy($symbol, $volume, $price) {
    		$value = $volume * $price;
    		if ($value > 1000)
    			throw new SpentTooMuchException(sprintf('You are not allowed to spend that much (%s)', $value));
    		return $value;
    	}
    
    	// [...]
    
    }

Run the tests and ensure that they fail:

Time: 0 seconds, Memory: 6.00Mb
    
    There was 1 error:
    
    1) BrokerTest::testBuyTooMuch
    Exception: You are not allowed to spend that much (80000)
    
    /home/csaba/Personal/Programming/NetTuts/Aspect Oriented Programming in PHP/Source/Application/Broker.php:20
    // [...]
    /home/csaba/Personal/Programming/NetTuts/Aspect Oriented Programming in PHP/Source/Application/Broker.php:47
    /home/csaba/Personal/Programming/NetTuts/Aspect Oriented Programming in PHP/Source/Application/Test/BrokerTest.php:24
    /usr/bin/phpunit:46
    
    FAILURES!
    Tests: 4, Assertions: 3, Errors: 1.

Now, expect the exception (in the test) and make sure they pass:

class BrokerTest extends PHPUnit_Framework_TestCase {
    
    	// [...]
    
    	/**
         * @expectedException SpentTooMuchException
         */
    	function testBuyTooMuch() {
    		$broker = new Broker('Finch', '2');
    		$broker->buy('MS', 10000, 8);
    	}
    
    }

Create a new method in our aspect to match @AfterThrowing, and don’t forget to specify Use Go\Lang\Annotation\AfterThrowing;

 // [...]
    Use Go\Lang\Annotation\AfterThrowing;
    
    class BrokerAspect implements Aspect {
    
    	// [...]
    
    	/**
    	 * @param MethodInvocation $invocation Invocation
    	 * @AfterThrowing("execution(public Broker->buy(*))")
    	 */
    	public function afterExceptionMethodExecution(MethodInvocation $invocation) {
    		echo 'An exception has happened';
    	}
    
    }

The @AfterThrowing matcher suppresses the thrown exception and allows you to take your own action. In our code, we simply echo a message, but you may do whatever your application requires.

Final Thoughts

This is why I urge you to use aspects with care.

Aspect oriented programming is like a new gadget for geeks; you can immediately see its great potential. Aspects allows us to introduce extra code in different parts of our system without modifying the original code. This can prove to be immensely helpful, when you need to implement modules that pollute your methods and classes with tightly coupled references and method calls.

This flexibility, however, comes with a price: obscurity. There is no way to tell if an aspect watches a method just by looking at the method or its class. For example, there is no indication in our Broker class that anything happens when its methods execute. This is why I urge you to use aspects with care.

Our use of the aspect to offer a discount for a specific broker is an example of misuse. Refrain from doing that in a real project. A broker discount is related to brokers; so, keep that logic in the Broker class. Aspects should only perform tasks that do not directly relate to the object’s primary behavior.

Have fun with this!

A popular app gets yanked from Apple’s App Store, illustrating the danger of betting it all on one mobile OS.

AppGratis, an iOS app that offers users a free app each day that they’d normally have to pay for, is having a rough week. On Friday, Apple removed AppGratis from its app store, saying it ran afoul of two store guidlines: one banning apps that promote other apps, and another banning use of push notifications to send ads or direct marketing.