1. Less wasted time: it’s more than what you’re probably thinking. According to Einstein, the faster an object travels, the slower time passes from that object’s perspective. I probably save a few trillionths of a second (maybe less) each time I commute… I’m hoping all that time adds up…
2. People stay still: Although some might freeze out of fear, I think that relativity also has a lot to do with this. Relative to my speed, foot traffic covers a small distance in the same amount of time it takes me to cover a larger distance, so an opening in the crowd that I see from 30 feet away will (more than likely) still be there by the time I get there.
3. Smaller target: Because of my speed, space distorts in addition to time maintain a constant speed of light. This makes my bike ever-so-slightly smaller than it actually is. Therefore, I can theoretically fit through smaller spaces.
4. Wider field of vision: From my perspective, as space distorts around me, my view of my surroundings becomes slightly wide-angled (“fish-eyed”). A larger view allows me to better see my surroundings.

So what if all of these effects are only noticeable when traveling close to the speed of light. I don’t ride my bike even remotely that fast (my average speed is usually around 15 mph / 24 km/h). However, I believe I’m feeling Physics withdrawal since I’m not taking any more PHYS courses, and my inner physicist is trying to find cool physics stuff in everything I do… all to make my life seem more exciting than it actually is all to help me further realize how amazingly exciting life truly is.

Forms (Symfony\Component\Form)

Forms are created through a Factory service (form.factory), which subsequently uses a Builder object, to automate the creation of fields and assembly of the Form Composite tree. The best way to illustrate and explain this process is to walk through an example usage scenario.

$myForm = $this->createForm(new MyType(), $entity, array(...));

Symfony’s Controller class (Symfony\Bundle\FrameworkBundle\Controller\Controller) defines the createForm method shortcut, which accepts the following parameters: a string identifier or an instance of a Type class, an entity to which the form will bind its information, and an array of options to pass to the Type’s buildForm() function. The last two parameters, the entity and the options array, are optional. If no entity is provided, then the data can be retrieved by calling $form->getData() after binding.

Controller::createForm() delegates to FormFactory::create(). FormFactory acts as a Façade to the Form component by automating and abstracting much of the creation process. FormFactory::create() then delegates to a FormBuilder object, which creates the form recursively for each of the nested Type objects. Afterwards, the FormFactory returns the completed Form tree by calling $builder->getForm().

class MyType extends AbstractType {...}

This is the definition of a Type class that will control how a node on the Form tree will be constructed by the builder. Note that Symfony 2 discourages users from directly defining Form subclasses: using the builder reduces dependency on the Form’s interface and allows its internal structure to vary as Symfony evolves without affecting the user’s code.

public function buildForm(FormBuilder $bldr, array $opts) {...}

This function is a member of the MyType class and is the callback for when a node of type MyType is created. The form factory passes a builder to this callback so this node’s children can be created (even recursively, if necessary by calling $fieldOrSubForm->buildForm($bldr, array(...))). The options are passed from the parent node (or the constructor if this particular Type object was instantiated) and can be used to dynamically configure form elements.

$bldr->add('name', 'text', array('required' => true));

This statement would reside in the definition of MyType::buildForm() and gives me the opportunity to explain how the builder works. The builder’s add function creates a child on the current Form node with the given arguments: name, type, options.

• The name acts as an identifier for the child (and the input field’s name attribute when rendered as HTML), much like the key to a PHP array value.
• The type is optional and can be either a string or an instance of Form (or any of its subclasses, including Type objects). If omitted, the builder can guess the type using doctrine metadata. If a string is given for the type, the builder uses it to look up the type class in a registry of built-in Type classes (all of which are defined in Extension\CoreType). I cannot determine whether the registry of built-in types follows the Flyweight pattern or the Prototype pattern (or a combination of both), but that’s not important now. If a Type instance is given, the builder can skip the lookup step and process it immediately. This is how one can embed a form within a form in Symfony 2.
• The options array will be used for configuration in the child node’s buildForm() method. Note that the ‘required’ option in the code example above is NOT a part of the validation model. Rather, it is an HTML5 attribute that is added to the rendered field for browser-based, client-side validation. This is not meant to be used in place of server-side validation as the ‘required’ attribute is not supported by all browsers.

When the builder creates a child node, it sets the new node’s parent reference to the current node that called for the child’s construction. The builder is actually a lot more complicated than how I have explained it here: it uses lazy loading so that it does not create any child objects until it absolutely has to. Calling $builder->getForm() triggers this mechanism. The resulting Form object will allow for data binding and validation and acts as a wrapper for the data object underneath.

return array('view' => $form->createView());

Because the Form object only serves as a wrapper to an entity, array, or other data form, it cannot be rendered into HTML as-is. To resolve this, the controller passes an instance of FormView to the templating engine at render-time. A FormView is a PHP abstraction of the HTML input tags and provides a way for the templating engine to iterate over the fields in the form.

In summary, the FormFactory is the main interface for the Form component; the FormBuilder is responsible for adding fields (Types) to the Form object being built; the Form is a lightweight composite wrapper for the data object that stores the information, and the FormView encapsulates information pertinent to rendering HTML input fields.

Entities

Dynamic web applications depend heavily on storing and retrieving data. Symfony has altered the traditional norm in favor of Domain Driven Design.

Entities are nothing more than plain-old PHP classes that mimic the properties and behavior of real-life objects. They do not extend any base Entity class and are thus entirely self-contained. This is another reason Symfony is so fast and lightweight. Entities help the Symfony framework feel more like working with a statically typed object-oriented language like Java or C++.

Entities are persisted by the Doctrine ORM. The ORM understands how to communicate with the entities because of the metadata information associated with the fields to be saved and by conventional getter and setter names. I prefer using annotations because I can define mapping and validation metadata for each field in the same file. I am also amused by the fact that Doctrine (and other Symfony components) can read and cache the PHPdoc comments that are ignored by the PHP interpreter. Symfony also provides ways to configure entity metadata using YAML, XML, or PHP files.

Validation (Symfony\Component\Validator)

Validation, the act of checking data legitimacy, has traditionally been closely integrated with forms: when a user submits data, a validation script checks that all required fields have been filled, certain numeric or date values are within a predetermined range, and email addresses are correctly formatted. Validation also applies on a coding level: a RESTful web service could submit information directly into the controller without the use of an HTML form; unit tests populate entities directly through setter methods.

Validation must be made available to both Forms and Entities. Symfony 2 solves this problem by extracting the validation subsystem into its own Validator component. According to the Symfony 2 online documentation, “This component is based on the JSR303 Bean Validation specification.”

Like Doctrine, the Validator component knows how to validate an object based on metadata, which can be defined on the Entity using Annotations or in separate YAML, XML, or PHP configuration files. Regardless of how the metadata is defined, the Validator caches it for faster performance.

There are two ways to use the Validator component: either directly or through the Form component. Using it directly is very straightforward. From the controller level, the Validator service can be obtained by calling $this->get('validator'). Inside a Unit test, the Validator is created with ValidatorFactory::buildDefault()->getValidator(). Once we have a Validator, we can pass it an entity to be validated:

$validator = $this->get('validator');
$errors = $validator->validate($entity);

When binding data to a Form, the Form object automatically transfers the data to the underlying entity object and calls the Validation component to check it.

God Bless America!

I just received word that the government is moving to pass a bill that would mandate the coverage of contraception and sterilization by health insurance providers. As I remember from high school biology, the ability to reproduce is one of the seven characteristics of life. Contraception/sterilization is a blatant insult to our human dignity—what it means to be a human being. The abortion industry has propagated the notion that pregnancy is a disease to be eradicated rather than the blessing of a child that it should be.

In my mind, this follows as a direct repercussion of the Obamacare bill that was shoved down the throats of the American people against our will. When that happened, I formed a line of succession that resulted in a dystopia like Aldous Huxley’s Brave New World or George Orwell’s 1984 as a worst-case scenario:

1. Government-regulated health care (“Obamacare”): the federal government sets the rules for health care and health insurance providers.
2. Government-mandated health care: American citizens are required to have health care insurance.
3. Government-owned health care: the government releases its own brand of health care.
4. Government-controlled health care: the federal health care system drives other privatized health care providers out of business with over-regulation.
5. Crisis/meltdown phase: federal health care will be in collapse due to uncontrolled spending and the lack of budgets.
6. Rationed health care: due to the limited funding, the government will only provide health care to people deemed “worthy” of it. This phase also comes with other moral issues such as euthanasia, government-mandated abortions, and birth (population) control, which might even result in a subtle ethnic cleansing… horrific.
7. Brave New Country: a quintessential dystopian environment: The federal government will be the ultimate authority, and all who oppose it or its policies will be reprimanded; children will be either government-sanctioned or grown in “farms”; and people will receive “your time has come” notices (a.k.a “death panels”) once they are labeled hindrances to society (through old age or injury).

I fervently pray that we never reach any of the later phases, but the current administration’s recent antics are definitely revealing a sinister plan that (so far) closely parallels this sequence of terrible events. The first amendment (freedom of religion, speech, press, and right to petition the government) is already being challenged, and I fear for the remaining liberties.

Keep in mind that these events are only worst-case scenarios: they do not have to be predictions (I dearly hope they are not), and even so, I do not foresee any “point of no return” because there is always time for redemption and common sense. We can still reshape this country into one that upholds personal freedom—the foremost of which is the right to life—and brings honor to God. Then and only then will this country once again be dignified.

It’s time to wake up, America!

I’ve previously written about the Symfony 2 PHP framework, and as the release date draws near (currently in RC6—it has to be soon), I’ve been trying to help the Symfony developers solve user-reported issues on their public repository. Many issues are categorized under “Forms”, so I’ve been trying to understand how Symfony’s Form component works. I had attempted to do this prior to reading Design Patterns and was very confused by all of the abstraction and delegation to other classes. Now that I understand more about software design, it’s much easier to fit the pieces together:

In Symfony 2, the Form component is a Factory Façade object that provides access to a Composite object (enabling embedded forms) that is created via a Builder that delegates type-specific configuration to Flyweight Type objects… These are just a few of the simple design patterns that I’ve read about!

There are many other design patterns used throughout the Symfony framework: a huge indication that it is well-designed. This is most likely the reason behind its incredible speed and low memory footprint.

(Click on a thumbnail to view a larger image)

Credits

• Photos by Jason Collier
• Copyright SeaWorld Parks and Entertainment

In general, Symfony 2 is much lighter and faster than all of the other PHP frameworks I’ve used (including CakePHP, Zend, and CodeIgnitor). At the time of writing, the current version is 2.0.0 Beta 3, and as I have learned more about this revolutionary redesign, I have come to understand more about the inner workings of the Internet rather than relying on “automagic” components. Symfony 2 offers a way of dealing with HTTP requests and responses in a familiar, object-oriented, MVC fashion. I won’t bother to explain the exact details, but I will summarize:

An HTTP Request begins its journey when the user performs an action on a web page. For simplicity, suppose the user clicks a link to an “About” page and makes a simple GET request. In a Symfony 2 application, the request is caught by the front controller, a single file that handles all requests and passed to a Kernel for processing.

The Kernel analyzes the request and matches it to a route defined in a cached configuration file. If the route matches a firewall pattern protecting a certain resource, then the user may be asked to provide authentication credentials (i.e. redirected to a login page). The route redirects the response and its parameters to a controller action that resides in a “Bundle”

The Controller handles the request and performs any logic to gather information from a database (if necessary). At this point, the “Model” paradigm has been replaced by Entities—plain-old standalone PHP objects that can be saved (or persisted) to a database by an external entity management service (in Symfony’s case, Doctrine). Symfony 2 also provides support for the Document storage design popularized by the MongoDB database engine.

After performing all necessary logic and processing, the action returns a response object, which could be anything from a redirection to a JSON file to an HTML page. This response is handed back to the client’s web browser.

Traditionally, HTML responses are rendered in templates. Symfony 2 uses a new templating engine called Twig, which uses syntax highly similar to the Python Django framework. The Twig is rendered as PHP and then cached for easy reuse.

Without any additional logic, a simple GET request in Symfony 2 takes less than 50 milliseconds to process, render, and return a response. A complex POST request that persists information to a database and fetches more information takes slightly longer: usually less than 100 milliseconds.

The Symfony 2 documentation offers more information, and I highly recommend reading the first couple parts it even if you aren’t a web developer. If, on the other hand, you are a web developer, Symfony is insanely fast, easy to learn, and powerful/flexible enough to customize your own core components.

I’ve had my eye on the Symfony 2 framework for quite some time. I plan to continue following its development and perhaps make a few contributions on Github.

While I’m thinking about it, Symfony 2 would make a good starting point for the web projects I plan to begin this summer. One of these projects is actually a series of sites for a local non-profit organization. I will be working on it with some of my friends who have amazing artistic talents: It is going to be awesome!

Of course I have to visit SeaWorld: Shamu has a new show One Ocean that promises to be just as breathtaking as Believe. I will definitely speak with some of the trainers I know there.

On the same aquatic note, I have to keep up my swimming endurance: SCUBA classes for the Fall semester require a 500 m swim and 10 minutes treading water. I will try to swim two times each week.

Abraham spoke up again: “See how I am presuming to speak to my Lord, though I am but dust and ashes!” (Gen 18:27)

Then I looked and there was the Lamb standing on Mount Zion, and with him a hundred and forty-four thousand who had his name and his Father’s name written on their foreheads. (Rev 14:1)

Revelation can be a very difficult book to interpret because of it’s apocalyptic style. In this verse, some might interpret the “a hundred and forty-four thousand” to be an exact number. When Revelation was written, a thousand meant an innumerable amount. Villages probably seldom had more than a few hundred people, so a crowd of a thousand would’ve been a very big deal. The number twelve in scripture is a reference to the twelve tribes of Israel. In this case, 144 implies twelve “sub-tribes” for every tribe, each with too many people to be counted. An easy way to remember and visualize the number and quantity is the 12^th Man.

The passage also describes the name of each person and the name of the Father on their foreheads. Each person’s name has two “parts”. First, our name was officially given to us at Baptism, hence an indelible mark that becomes our identity in Christ; second, we are of this world, mortal, dust. The second name, the Father’s name, is an identity for God—the cross. Thus an ashen cross is a physical representation of what Rev 14:1 describes.

For even more information, check out this post from St. Mary’s Aggie Catholic Blog.

In memory of Dawn Brancheau
February 24, 2010
[SVG Version]

I want Dawn’s family, friends, and coworkers to know that they still have my sympathy and will continue to remain in my prayers. Please keep all of these people in your prayers as well and spread the message that Dawn will never be forgotten.

The memorial ribbon at left is what I remember from a photograph taken at Dawn’s funeral. It is public domain and free for anyone to reuse without citation or attribution.

Ever since this tragic event, SeaWorld trainers have not been allowed to get in the water with the orcas. However, SeaWorld recently announced that trainers will be allowed to do limited “water work” with the orcas in the smaller pools. After investing in special safety floors that can lift out of the water in the event of an emergency, SeaWorld hopes to eventually return the unique breathtaking intimacy to their shows.