As I wrote a few days ago in my blog, MySQL is participating in the Google Summer of Code 2007.

The application process for students has now been opened! You have just one good week of time to apply, as the window closes 24 March 2007.

To participate in MySQL Summer of Code,

1. Read my blog announcement on http://www.planetmysql.org/kaj/?p=89
2. Read Google’s Guide to the GSoC Web App for Student Applicants at http://groups.google.com/group/ google-summer-of-code-announce/ web/guide-to-the-gsoc-web-app-for-student-applicants
3. Go to the http://forge.mysql.com/wiki/SummerOfCode page to pick one or several MySQL related projects that interest you
4. Load the http://forge.mysql.com/wiki/SummerOfCode/ApplicationTemplate page for the MySQL related application template, to use as a reference for when you fill in the application itself in the next step
5. Go to the Google Summer of Code Student Signup page at http://code.google.com/soc/student_step1.html and start the signup process itself. Be prepared that it can take a while to fill in.

When filling in the GSoC application, remember that we expect you to follow our Application Template mentioned above. I.e.

• Your application needs to be concise.
• Your application needs to follow our format.
• First you give us your personal details,
• then what you plan on doing,
• then all your actual experience (broken down, for easy reading),
• then what exactly you intend on delivering (the most important part), and
• finally, a simple Yes, I’m willing to sign the MySQL CLA at http://forge.mysql.com/wiki/MySQL_Contributor_License_Agreement

If at any point you need assistance, please don’t hesitate to contact MySQL’s Summer of Code Project Administrator Colin Charles (colin@mysql.com).

The early registration of the MySQL Conference & Expo 23-26 April 2007 closes today, 14 March 2007. So if you want to cut your attendance costs by 200 US dollars, register now!

Quoting the About The MySQL Conference & Expo page:

The MySQL Conference & Expo will feature:

• Over 100 sessions for a wide range of skill levels
• Tutorials to help develop technical skills and learn new tricks
• More than 2000 MySQL developers, gurus, experts, and users under one roof
• Dozens of new tools and technologies from third party vendors in the Expo Hall
• Birds of a Feather sessions, evening events, and networking opportunities.

That listing obviously misses the most important point:

• The Clash of the DB Egos, a provoked fight between some of the most opinionated two-initials DB gurus the world has seen

I’d love to see you there!

Finally!

We have a release of MySQL Community Server that contains community-provided contributions and it is ready for your download in binary form.

Thanks to Jeremy Cole for providing us with the SHOW PROFILE patch. Quoting our Reference Manual at http://dev.mysql.com/doc/refman/5.0/en/show-profiles.html:

SHOW PROFILES

SHOW PROFILE [type [, type] … ]
[FOR QUERY n]
[LIMIT n [OFFSET n]]

type:
ALL | BLOCK IO | CONTEXT SWITCHES | CPU | IPC | MEMORY | PAGE FAULTS | SOURCE | SWAPS

The SHOW PROFILES and SHOW PROFILE statements display profiling information that indicates resource usage for statements executed during the course of the current session.

Profiling is controlled by the profiling session variable, which has a default value of 0 (OFF). Profiling is enabled by setting profiling to 1 or ON:

mysql> SET profiling = 1;
SHOW PROFILES displays a list of the most recent statements sent to the master. The size of the list is controlled by the profiling_history_size session variable, which has a default value of 15. The maximum value is 100. Setting the value to 0 has the practical effect of disabling profiling.

All statements are profiled except SHOW PROFILES and SHOW PROFILE, so you will find neither of those statements in the profile list. Malformed statements are profiled. For example, SHOW PROFILING is an illegal statement, and a syntax error occurs if you try to execute it, but it will show up in the profiling list.

SHOW PROFILE displays detailed information about a single statement. Without the FOR QUERY n clause, the output pertains to the most recently executed statement. If FOR QUERY n is included, SHOW PROFILE displays information for statement n. The values of n correspond to the Query_ID values displayed by SHOW PROFILES.

The LIMIT n clause may be given to limit the output to n rows. If LIMIT is given, OFFSET n may be added to begin the output n rows into the full set of rows.

Some sample output:

mysql> SHOW PROFILES;
+----------+----------+--------------------------+
| Query_ID | Duration | Query                    |
+----------+----------+--------------------------+
|        0 | 0.000088 | SET PROFILING = 1        |
|        1 | 0.000136 | DROP TABLE IF EXISTS t1  |
|        2 | 0.011947 | CREATE TABLE t1 (id INT) |
+----------+----------+--------------------------+
3 rows in set (0.00 sec)

mysql> SHOW PROFILE;
+----------------------+----------+
| Status               | Duration |
+----------------------+----------+
| checking permissions | 0.000040 |
| creating table       | 0.000056 |
| After create         | 0.011363 |
| query end            | 0.000375 |
| freeing items        | 0.000089 |
| logging slow query   | 0.000019 |
| cleaning up          | 0.000005 |
+----------------------+----------+
7 rows in set (0.00 sec)

This information is also visible in the corresponding INFORMATION_SCHEMA.PROFILING table.

Unfortunately the SHOW PROFILE implementation as of 5.0.37 still has a small gotcha, that we will resolve for the next release: the MySQL command line client hangs if you issue the SHOW PROFILE command without having enabled the @@profiling session variable before. Hence, when you evaluate this new feature, make sure to enable it by issuing “SET @@profiling = 1;“ before.

In summary, the SHOW PROFILE patch provides a way for the MySQL Community Server users to get a more detailed understanding of where the response time is formed. Jeremy also contributed a patch to display the Uptime_since_flush_status status variable, which indicates the number of seconds since the most recent FLUSH STATUS statement. Thanks, Jeremy!

Looking beyond the community enhancements, MySQL Community Server 5.0.37 is our second full (source and binary) release of the MySQL Community Server since we made the split between the Community and Enterprise Version in October 2006. It includes all bug fixes applied to up to and including the MySQL 5.0.36 Enterprise Server. The prior MySQL Community Server 5.0.33 release early January 2007 was a source-only release.

The 5.0.37 release also resolves a crashing bug that could be exploited as a potential local Denial of Service attack. Thank you, Stefan Streichsbier from SEC Consult, who also informed us about this bug via our security@mysql.com mail address - he will send out a separate advisory about his findings.

We welcome and appreciate your feedback, bug reports, bug fixes, patches etc. as described on MySQL Forge on http://forge.mysql.com/wiki/Contributing.

The MySQL Community Team has been strengthened, getting an Engineering arm able to process code patches.

Giuseppe Maxia	Chad Miller

In an effort to align MySQL company resources to support an Architecture of Participation, we have reallocated Chad Miller and Giuseppe Maxia from the Engineering team to form the Community Engineering team. Chad is allocated towards enabling us to quickly review code patches (bug fixes, new features) and Giuseppe towards our Quality Contribution Program.

Looking at this from a Community perspective, this forms the following step in the process of opening up our Development Model and supporting the Architeture of Participation. Looking at it from an internal company perspective, this forms the following step in the specialisation of resources — a development which started more than five years ago when we dedicated some of our engineers mainly to Support, while others remained in Development.

No matter from which perspective you look at it, the establishment of the Community Engineering Team is intended this to increase our level of responsiveness to community contributions. And that is an area where we still have room for improvement. Our bugs system contains some skeletons in the form of pending community-provided patches, such as the performance enhancements of Gunnar von Boehn. The Engineering department has been busy fixing bugs according to certain priorities (which aren’t wrong per se), and the Community department has lacked the technical expertise to be able to safely apply patches. Now, we have an organisational unit which has as its main priority to work for and with community contributors, and which has the technical skill set required. This unit, Community Engineering, only depends on the rest of Engineering for reviews.

I’ve already mentioned it in my Summer of Code blog entry, but it bears repeating: We’ve seen some early wins based on this organisational change. One of our top Quality Contributors, Martin Friebe, submitted a bug report including a test case and a bug fix code patch. Through the allocation of Giuseppe and Chad to Community Engineering, the patch was verified and applied to the tree within two hours of the bug report. I hope we are able to continue down this road!

Welcome, Giuseppe! Welcome, Chad! And thanks to our VP Engineering, Jeffrey Pugh, for letting me have them!

What happened with the MySQL Winter of Code? It was hit by Global Warming. Specifically, the Community Team got heated up working on the MySQL Conference & Expo 23-26 April 2007, left with little bandwidth to pursue the ideas and action items for Winter of Code.

When winter warms up, it slowly turns into summer. But the coding work remains. Colin Charles was smart enough to combine these two facts with Sheeri Kritzer’s blog entry and hints about the Australian Winter, and took action related to the Google Summer of Code. Colin spoke to Chris DiBona and Leslie Hawthorn of Google and has now signed us up for Google Summer of Code.

In short: We are transitioning the Winter of Code to the Google Summer of Code, and we today sent in our application to Google.

While I am not happy about our not having been able to devote the necessary resources to our WoC, I am happy that the Quality Contribution Program has been launched and had some early successes — like when Martin Friebe submitted a bug report including a test case and a bug fix code patch, which enabled usto verify the bug and apply the fix within two hours of the bug report. Thanks Martin Friebe, Giuseppe Maxia and Chad Miller!

In an attack of misguided pride, we at MySQL AB could choose to feel bad about not having found or fixed that bug ourselves. I don’t. Bugs are a fact of life, and it’s our task to architect our model so that they’re fixed fast. We hate bugs! And we love those who help us kill them!

The Quality Contribution Program has oiled our internal processes for being able to receive, process, review and accept external patches — something which we traditionally haven’t been good at.

In fact, we haven’t been creating as much of an Architecture of Participation at MySQL, as we should expect. What’s an Architecture of Participation? Let me quote the two first sentences from Wikipedia:

The phrase architecture of participation describes the nature of systems that are designed for user contribution, such as open source and Wikipedia. It was coined by Tim O’Reilly, who described it at length in a 2003 speech and later in several of his online writings.

The phrase has come to define one of the key elements of what’s been called Web 2.0, which describes the collection of companies, technologies and projects that are designed around the culture and economics of openness.

Now starts the next step in opening up the MySQL Development Model. The two things that SoC require of us are the same as what an Architecture of Participation requires of any organisation:

(i) identifying mentors
(ii) identifying features to implement

Identifying mentors: Experienced developers need to “Adopt A Programmer” and guide these contributors on the MySQL source code, and how to implement the features they (or we) want them to develop. This takes several hours a week, but if well done, it’s as rewarding for the mentor as it is for the students being guided.

While folks running MySQL University are ideal mentor candidates, I would argue that students at MySQL University also qualify. We absolutely want more than the topmost ten hotshot developers at MySQL as mentors.

Identifying features: In the tentative Winter of Code plans, we proposed large, ambitious tasks

• Improvements to (pure drivers for) Perl, Apache APR, Python, Ruby or new connectors for emerging environments
• New Storage Engines: The Mail Inbox Format Storage Engine, the File System Storage Engine for Windows, for Mac, for Linux, or the Digital Picture (JPG / EXIF) Storage Engine

However, for SoC, we have tasks of all ambition levels — and have not limited ourselves to entirely new features. Jeffrey Pugh, our VP Engineering, and his Dev Leads have provided Colin with a digested list, that Colin is managing at http://forge.mysql.com/wiki/SummerOfCode and that currently has the following item headers

• Test Suite Development (Stewart Smith)
  mysql-test-run.pl and mysqltest
• Test case development (Giuseppe Maxia)
  Code coverage improvement
  System Tests - Load Tests and Long-Running Tests
  Test creation tools
• Benchmarking the MySQL Server
• Instance Manager fixes
• Integrate MySQL Cluster with Instance Manager
• INFORMATION_SCHEMA tables for MySQL Cluster status
• MySQL Based Atom Store
• Simple P4 bugs/features involving options/flags on bugs.mysql.com
• Simple features from Worklog, our detailed todo list

At last query, the MySQL bugs system had over 1,499 bugs filed in a Priority 4 state, which means they’re Feature Requests (Severity 4). While all of these are “up for grabs”, we don’t expect our Summer of Code students to pick their favourites from such a long list. Soon, we’ll rank the top ones based on our judgement of how interesting the features are to use, and how easy they are to develop.

So, if you’re interested in participating in our Summer of Code, what should you do?

1. Look for interesting projects in our project list on MySQL Forge.
2. Fill in an application according to our application template, also on MySQL Forge. Do this on the Google Summer of Code web app that will be live from 14 to 24 March 2007.

And if you have questions, feel free to contact Colin Charles and/or myself over email, firstname@mysql.com.

Would you like to experience a battle between E. F. Codd, C. J. Date, U. M. Widenius, J. A. Starkey and U. M. Ronström? Some of the biggest egos the database world has seen!

Well, I cannot promise you all of the above, especially when it comes to Codd, the father of relational databases (1923-2003). Codd’s colleague Date might also be a no-show, but I think I can promise you Widenius (MySQL, MyISAM), Starkey (Datatrieve, Interbase, BLOBs, MVCC, Falcon) and Ronström (NDB Cluster). During the Wednesday keynote at the MySQL Conference & Expo 23-26 April 2007 in Santa Clara, I will be provoking a fight about what constitutes a database, what’s the right way of doing locking, whether it ever was smart to store BLOBs in a database to begin with, and who ever needs versioning.

Given how I know said egos, I don’t expect it to be hard to throw in a couple of sentences that will fire off a slight disagreement between the gentlemen. And during the course of the discussion, I plan to bring in a few more egos, from Solid and Nitro.

Let the battle begin!

In my blog entry about How to arrange a physical meeting in a virtual organisation, I indicated that MySQL AB would arrange its next Developer meeting early in May 2007. For various reasons, including avoiding a crash with the MySQL Conference & Expo 23-26 April 2007 in Santa Clara, we postponed it to September. Our finalists were Sofia, Heidelberg, Munich and Vienna, where Germany’s Next Top Dev Mtg Location was choosen to be Heidelberg, one of Germany’s most charming cities ideally located at about one hour’s shuttle distance from Frankfurt Airport.

As part of our 2007 overall theme to open up our Development Model, we expect to open up attendance for some external community members. If interested, please email both Lenz Grimmer (Community Relations Mgr, Europe) and myself at firstname@mysql.com.

Coincidentally (honestly!), the Developers Meeting ends on the Tuesday right after the world’s biggest party Oktoberfest has started. So whoever joins us should consider flying into and out of Munich instead of Frankfurt, and spend 3 hours each way on train. And book early, since another 5 999 999 visitors are expected in addition to yourself.

I’m listening to the first MySQL University session. It’s the highest form of education available at MySQL AB, hence the name. Not about how to use MySQL, but how to write code patches for MySQL.

Right now, Sergei Golubchik is sitting in Cologne, Germany, speaking behind Skype Conferencing and two pillows (sound quality!) about memory management and mysys libraries and algorithms. Monty and others are assisting Sergei over our internal IRC, where there are 31 developers listening in.

Our presenter, Sergei Golubchik, in a non-virtual setting

Here’s an IRC transcript:

monty|uni ie, only destructior is called, memory is not freed until free_root()
rafal|school monty|uni: if I initialize String from other String, or char table[] or “string constant”, is memory allocated/deallocated correctly?
iggy|uni serg, While talking about alloc/dealloc for Strings, could you comment on the usefullness of SAFEMALLOC and how to take advantage of it?
monty|uni rafal|school: should be
rafal|school monty|uni: ok (thanks for all answers)
monty|uni Note that String can be both a pointer (like char*) and a C++ like string that holds the string itself
monty|uni If you use it as a pointer, you don’t get it freed. If you use it as a string (or convert it from pointer to string with String.copy(), you need to free it
monty|uni Using delete works on both cases
monty|uni so to be safe, you should just call delete on all String objects.
rafal|school monty|uni: how String can be used as a pointer?
mats|phone monty|uni, So that means that you have to allocate memory for a C string if you are passing it into the String constructor?
monty|uni Default is pointer
monty|uni mats|phone: or you use string.copy()

It’s a challenge. I’m not talking about understanding the routines, like

• init_alloc_root() - Initalize a MEMROOT object
• alloc_root() - Allocate an object
• multi_alloc_root() - Allocate many objects at once
• free_root() - Free everything

nor about understanding Serg’s accent. Everyone at MySQL has an accent. Our internal language is Bad English, and I feel competent to conform.

The challenge is the low bandwidth. I’m also sitting in Germany, and sadly, it sounds as if Serg were speaking through two pillows.

So why am I writing about this? Because we are planning to open up MySQL University. We are thinking of moving the IRC chat to freenode, and the Wiki pages to the MySQL University Library on MySQL Forge Wiki. The sound already is public, on Skype Conferencing.

With the open MySQL University, those who have an interest in learning about MySQL’s internal code structure can listen in, or follow the MP3 recording later on, or just browse the MySQL University Library. Stay tuned — we hope to be able to open up these weekly sessions later on in March.