Self-Referencing Tables

A self-referencing table is one that has a foreign key pointing to the same table. For example, a folder hierarchy might have a parent_id column referring to its parent folder. Deleting a single row that has children should normally fail. But what if you wanted to delete a whole tree at once? Would you go recursively from the bottom up?

Solution

A simple way to achieve this is to use the following statement before: SET FOREIGN_KEY_CHECKS=0; This will prevent the MySQL database from complaining about the integrity constraint.

To achieve this using Doctrine, you can execute a raw query using the currently opened connection. Use the table name from which you expect to delete later, to make sure that the right connection is used.

Doctrine::getTable("TableName")
  ->getConnection()
  ->getDbh()
  ->query("SET FOREIGN_KEY_CHECKS=0;");

Now run your delete queries. Don’t forget to SET FOREIGN_KEY_CHECKS=1; at the end if you expect to execute more queries later on using the same connection.

Here’s an example of a delete query with Doctrine:

Doctrine_Query::create()
  ->delete()
  ->from("Folder")
  ->where("id > 25")
  ->execute();

Best Practices

You add database constraints for a reason and pointing to inexistant records compromises your data’s integrity. This approach assumes that you know in advance that removing the row set is alright. I only use this method in maintenance scripts, not in the normal application flow.

The purpose of this post is not to transcribe the podcast, but to share with you what I learned from this conversation and what I personally took away from it.

The Culture and the Issues

Although many say that the culture does not make women flee or prevent them from joining, Laura argued that it may, at the very least, prevent women from contributing. While it would seem that the culture doesn’t want to change, Liz said that many men participate in criticism against sexist behavior, which shows that the community actually cares for an attitude change. She also supported empathy and respect as opposed to only increasing the number of women in tech, which is also a big part of the desired change.

I have a problem with the way some of the sexism issues are brought to attention. I believe Twitter to be a poor medium: no body language, no intonation and only 140 characters at a time. When someone is being impolite or curses, a dialog is hard to establish and important issues often get overlooked because of that. Beth agreed with me that swearing and getting confrontational is not helpful, but we do need to address the problems regardless.

Brand Hygiene and Admitting Wrongs

We agreed that the nature of the brand or the gender of the perpetrator do not matter. Having women dancing around in underwear, when associated with a brand, will project a certain image of that brand. It’s up to the brand to decide whether it is the image that it is looking for.

I came to understand that no matter in what manner issues are raised, they should be treated as basic customer service issues. A company should not take it personal. Implied economic threats (by bringing employers into a discussion) are unethical and need to be avoided at all costs.

Liz taught us that it’s ok to apologize, even if we didn’t mean to offend. “When you bump into someone on the street, whether or not you meant it, you say that you’re sorry.” I hope that nerds will find it easier to admit a wrong with this analogy in mind.

Will the Industry Mature?

Liz argued that if left to our own devices, no change will come. Beth stated that sexist behavior is not appropriate, no matter how young you are. “Young people have the same capacity to reason as older people.” Also, such behavior is not limited to young people and it’s unfair to blame it all on them. In the meantime, Laura said, we must be allowed to be creative and enjoy our industry. That means calling out people who step out of line.

Conclusion

We have come to an agreement that spending all our efforts criticizing bad behavior takes effort away from doing something about it. It’s alright to point out something inappropriate to help people recognize when they have done something wrong. According to Beth, the real way to solve this problem is to “mentor and encourage people who are feeling excluded or discouraged and help them out, be it women or other minority group that’s feeling left out”.

It’s good to have groups that help these minorities, as long as it doesn’t exclude others, because then they will be separated once more. One such group is PHP Women.

I will personally be presenting a PHP Workshop for Women with the support of Montreal Girl Geeks next month. I will post a link as soon as we have details about the venue. I’m still looking for training assistants as well. Tentative date is April 26th.

It starts with the lack of females in this field. Prejudice or discrimination don’t prevent women from choosing IT, but they can certainly make life hard. These problems exist in every field though…

The real issue, in my opinion, comes from how parents stimulate their kids. We buy Tonkas and Legos for our boys, Barbies and winged ponies for our girls. If the girl never developed her spatial-temporal reasoning because she didn’t have the right tools, then she will have a hard time with software analysis and design. She will probably not be attracted to it at all.

Don’t most girls dream of being a doctor or a teacher? They were caring for dolls all their childhood. Don’t all boys dream of being a detective or an astronaut? They were building spaceships with their Lego. They were certainly not discriminated into choosing these fields at the age of 5.

I see a simple and lasting solution: stimulate both genders with the full range of toys early on (as soon as they are born). I had all kinds of toys in my youth, and so was not stuck in a limited range of possible careers. I chose programming when I was 11 and I still love it. That didn’t prevent me from having a keen interest in health, psychology and child education either.

Do you have other solutions?

Turn On the Slow Query Log

I once had a server with 7.1K slow queries. Here’s how to see which queries are slow:

1. Find the configuration file named my.cnf
2. Configure the location of the file where to log the queries, and set the minimum time, in seconds, that the query should run to be considered “slow”.
   log-slow-queries = /var/log/mysql/mysql-slow.log
   long_query_time = 1
3. Restart MySQL and start poking around your application (or run automated tests, if you have written any).

Inspect Server Statistics

I know of two ways to view server stats:

1. by running the command SHOW STATUS; in MySQL command-line,
2. by clicking on the Status tab in phpMyAdmin

Example: select_full_join must be 0. If not, the description recommends me to check my table indices. Try checking these stats on a production server, where the load is more realistic, and some of the red flags will only be raised when you have many concurrent users.

If you run into high numbers in the innodb_row_lock group, you can use the InnoDB monitor to check in real-time which tables are locked. Note that if too few users are using the application, this monitor may not show any rows. SHOW INNODB STATUS;

If you are not sure why certain values are too high or how you can improve them, search for the variable names online. I always document the values before and after I make optimization changes.

Conclusion

This should give you a starting point to begin profiling your queries. Not all the problems can be solved with proper queries; be ready to look into hardware, configuration and table structure/indices. Happy profiling!

In my next article, I will talk about the usage of EXPLAIN.

At FooLab, we have been using jQuery because it’s easy to learn, there is a big community with a lot of examples and advice and also because it’s easier to find developers familiar with it. It’s not a bad framework, but it’s very easy to abuse when you do not know how it works and what it implies.

Selectors

Consider these two selectors: “.photo” and “#photo”. The first one will force jQuery to go through every single DOM element, searching for the class attribute, searching for the one containing the word “photo”, because you can have multiple class names separated with spaces. Now imagine that you do that for a dozen selectors, inside a function that can be executed multiple times per second. The second selector will simply go and get the element by id, directly. No traversing.

You can’t always use ids, but you can help jQuery narrow the scope. You can define a scope using a second parameter: $(“.photo”, container). In this example, container = $(“.container”) so jQuery has no business traversing elements outside of that container. If the container has an id, then you can just write $(“#container .photo”).

You can also prevent jQuery from traversing every element by specifying the node name $(“div.photo”). This way, jQuery will not have to check the class attribute if it’s not a div. Yes, it is more flexible to use the same class across various HTML tags, but you have to make a choice.

Sometimes you will win a mere 0.5%, and sometimes you will win 2,485% performance increase and be really happy that you read about selectors. These tips can also be applied to CSS selectors, to style your page faster.

The getComputedStyle()

When you change the size of an element in the middle of the page, the browser has to recalculate many (if not all) element sizes to render your page correctly. And we’re not just talking about height x width. Borders, padding, margins, line-height all have to be taken into account. We don’t think much of it when the page first loads, because we attribute it to the network latency, but rendering a page is actually a lot of work. If you ever move elements around dynamically and notice a delay, that’s how much time it takes… with all your CPU cores.

Say you are using the jQuery UI Button to skin your elements. The page is loaded with default button elements. All is calculated and positioned. Then for every single .button() you call, the size of that element changes, and the entire page is redrawn. So for an initialization function calling 20 .button(), you get 20 page redraws. You may even get that problem when you enable and disable the buttons dynamically. If you’re only using .button() for skinning, it’s better to let go and use CSS instead.

The hide()

This one is related to the above measuring issue. When you .hide() an element, jQuery sets the display:none style, the space occupied by the element becomes empty and the page has to be redrawn. Whenever you can, set visibility:hidden instead. I once got a 2,740% performance increase on a commonly used function, with just that little thing.

Read my previous article to learn how to find the areas of your application that are eating the most CPU.

Some of the web apps that we build at FooLab rely heavily on Javascript. But when your CPU usage is through the roof, where do you start looking?

Methodology

Many developers start straight with a hypothesis and then try various corrections until something happens. This is a waste of time; no amount of experience changes that. Here’s I do it:

1. Ask a question

“Why is my machine using so much CPU?”

2. Observe

I use Chrome Developer Tools to poke around at first. Under the profiles tab, I start recording, perform the actions that seem to be causing the problem a few times and press stop. I remember seeing similar tools in Firefox and Safari.

There are many ways to analyze the data, but I found that sorting by Total to be most helpful. The Total is the time spent in the function and all functions called from within it, giving you the scope to look in.

3. Propose an explanation

Concentrate on functions that you wrote yourself, and then see in your code what they do. Try to think of any processes can be slow, unneeded or executed more times than needed.

4. Benchmark

I use benchmark.js which I include this file in my page. Then I add the necessary code to run the functions spotted in step 2. I like to run this code right after my home-brewed MVC has done initializing:

var suite = new Benchmark.Suite;
suite.add('addEventListeners', function() {
  addEventListeners();
}).add('render', function() {
  render();
}).on('cycle', function(ev, bench) {
  console.log(String(bench));
}).run({
  'async': false,
  'minSamples': 50
});

This will output a line for every .add you have, telling you the number of operations per second and margin of error. Rerun it if the margin is too wide. Make sure that you benchmark as many functions as you can before you start patching it. Write them in a table so that you can later compare with the improved code.

5. Fix the code

Now go ahead and start making adjustments. It’s good to make one type of optimization at once and run the benchmark again, writing all the numbers in a table side by side. Example: optimize jQuery selectors first. This way you can see which functions have been improved how, leading you to avoid certain mistakes in the future and having something to demonstrate and teach to your teammates.

Read my next article about some of the common places where jQuery murders your CPU.

Get the values by type

Default values are what you will be presented with when you display an empty form.

Get all values using $form->getDefaults() or a single value using $form->getDefault($name).

Record values, which are merged with the default values, are displayed when a Doctrine record is associated with the form.

Get all values using $form->getDefaults() or a single value using $form->getDefault($name).

Original POST values are displayed when the form validation failed.

Get all values using $form->getTaintedValues().

Clean POST values are the ones that have been validated and transformed by the form validators. At that point, you will most likely choose to save the form and redirect.

Get all values using $form->getValues() or a single value using $form->getValue($name).

Get all values regardless of origin

In one scenario, I needed to access the form’s values to inject them into Javascript. There is a method to extract a value as it will appear in the HTML, without worrying about whether it’s default, record, dirty  POST or clean POST.

Get the value directly from the field using $form->offsetGet($name)->getValue(). Alternatively, you can use $form[$name]->getValue() which will yield the same result.

I’m here to tell you that all languages are great and suck in their own way. There is no need to switch to a language just because someone told you that it was better; that’s often irrelevant, although counter-intuitive. You will always be more productive with the language that you have worked with for the past 10 or more years. While you spend another 10 years becoming an expert in a new language, you’re providing lower value for your customers. And what if by the time you are finally done switching, a shiny new awesome language comes out? You’ll be chasing your tail all your life. It’s like trying to keep up with teenage fashion.

If you’re fresh out of college, the same rules don’t apply. You’re not an expert in anything yet, even if your youth arrogance screams otherwise. You haven’t dealt with clients that will have your head on a spike if you don’t meet the deadline. You didn’t have junior freelancers do half the work, encrypt their code and disappear. You didn’t have to take over large teams that wasted millions of dollars and haven’t even finished arguing about the framework. Those are the real problems.

When you didn’t swear any allegiances yet, you are free to choose your language. So choose one that has potential in your eyes, one that has strong community support (even if it’s not an open source language), one that has good job prospects, one that has training and conferences available… this is what’s going to affect your life most, and not some pretty syntax.

In conclusion, I’d like to say that it’s not helpful to attack a programming language based on function names, frequency of releases, syntax, market share and other meaningless aspects. The real questions that you should be asking are whether your sh*t can be written in that language and whether you can get a well-paid job or contract. Finally, a diversity of languages and philosophies should be encouraged, so that we can learn from them and bring the concepts back to our own little world and flourish.

Do you enjoy soft drinks? Do you drink the diet version for less sugar? Many of these drinks contain cancerogenic additives, especially the sugar-free versions. Read until the end for a not-so-drastic solution.

The numbers

Product   | Volume | Calories | Sugar | Cancerogenic Ingredients
---------------------------------------------------------------------------------------
Coke      | 237ml  | 100      | 27g   | Caramel coloring
Diet Coke | 237ml  | 0        | 0     | Caramel coloring, aspartame, potassium benzoate
Guru      | 250ml  | 100      | 25g   | None

The explanation

Coke contains caramel coloring. That subtance contains compounds proven to cause cancer in mammals¹.

Turn to Diet Coke to save a few calories, and it gets scarier: three ingredients cause cancer. Aspartame causes cancer over a long-term consumption and is especially dangerous for children². Potassium benzoate, much like sodium benzoate, reacts with vitamin C to create small amounts of benzene: a chemical that causes leukemia and other cancers³.

Guru, on the other hand, contains less sugar, even for a higher volume. Sugar comes from sugarcane which is more expensive to produce. It contains guarana, a common ingredient in soft drinks in South America. It’s high in caffeine but is not dangerous when consumed moderately.

Nobody lives forever, say you?

Even infants have been diagnosed with cancer and one may suffer all his life instead of dying. I had a friend in his early thirties who had colorectal cancer. This means that he had to wear adult diapers so we wouldn’t defecate in his underwear. It was painful and embarrassing for him. He did not catch it early, so he will bear it all his life.

The lesson

Our bodies are so complex and different that there are no absolutely safe substances out there. Even water can be fatal if consumed abusively⁴. Consuming generally safe products in moderation is a good bet.

Many companies, striving to make increasingly cheaper and appealing products, often use cheap artificial alternatives to common ingredients. It’s mostly the consumer’s fault. We ask for cheap products, good food texture, long conservation, availability all year round and other follies. There is no point in blaming companies for satisfying our impractical requests.

I am ready to pay double or even triple for my grocery if that means living cancer-free until the ripe age of 120. Are you ready to sacrifice some extravagant requests to live healthier? Will you demand a more expensive but safer product variations from your favorite companies?

References

1. The “caramel coloring” used to color all the top cola brands isn’t natural caramel coloring at all. Instead, it’s made by reacting sugars with ammonia and sulfites at high temperatures. This reaction results in the formation of 2-methylimidazole and 4-methylimidazole, both of which are chemicals documented by the U.S. government to cause cancer in mammals.

http://www.naturalnews.com/031383_caramel_coloring_cola.html

2. [The study] indicated that rats first exposed to aspartame at eight weeks of age caused lymphomas and leukemias in females.

http://www.cspinet.org/reports/chemcuisine.htm#aspartame

3. Another problem occurs when sodium benzoate is used in beverages that also contain ascorbic acid (vitamin C). The two substances, in an acidic solution, can react together to form small amounts of benzene, a chemical that causes leukemia and other cancers.

http://www.cspinet.org/reports/chemcuisine.htm#sodiumb

4. Water can be considered a poison when over-consumed just like any other substance.

http://en.wikipedia.org/wiki/Water_intoxication

Failed attempts

sudo ruby ~/Downloads/rubygems-1.8.6/setup.rb
sudo gem update --system
sudo gem install rubygems-update --source http://production.s3.rubygems.org/
update_rubygems

Successful attempt

sudo gem update --system --source http://production.s3.rubygems.org/yaml