Welcome to this seventeenth issue of the LilyPond Report!
Yay, the Report is back, with a new team! It has been said that two heads are better than one — does it apply to newsletters as well? Read on and let us know! In this issue we’ll talk about websites and poetry, frogs and bugs, not to mention an extensive review of the Frescobaldi editor!
As always, you can post your comments at the bottom of the page, or even register and contribute to the LilyPond Report’s next issues.
Editorial
At last, the Report is back! Hopefully for long, since it is now being handled by two editors, namely yours truly and… (wait for it…) Graham Percival himself!
When he’s not living without the Bunnies in Glasgow, Graham `I’ll be gone in a month’ Percival is still on board, grumpier as ever. As a result, you can expect the new Report to have a very different tone than it used to have in the past!
Our goal is to publish this newsletter on a bi-monthly basis (that is, every two months, not twice a month). Is it reasonably achievable? Well, it depends.
If we try and keep up with the mailing lists and the LilyPond community, then two months is just ridiculously too long: that amounts to four development releases, dozens of major decisions, hundreds of bug reports, thousands of (often interesting) discussions… On the other hand, if we manage to keep our heads above the water and only mention carefully selected items, then the Report might give an interesting perspective, less directly concerned with the community’s everyday life.
But most of all, as I repeatedly said for the past couple of years, the Report needs your contributions! I know I haven’t been quite reliable in running it, but it’s somehow a pity that the first person who finally stepped up and offered to give me a hand is also the one who’s desperately been trying to leave the LilyPond project for the past three years,
- The new LilyPond Report, live from Hogwarts
Nevertheless, as Graham said:
A very grumpy Report may or may not be funny; on the other hand, maybe if there’s 1 or 2 very grumpy reports, people will get motivated to write something, if only to make it more enthusiastic!
Cheers,
Valentin.
Behold our new website!
The new LilyPond website is nearing completion. If you haven’t taken a look at it yet, try reading it now!
(Note that the translation infrastructure is not yet completed for the new website.)
If you have any design suggestions, it’s not too late to make changes — get in touch with us.
Release news
The current stable release is 2.12.3-2; all normal users should be engraving with this version. We have no plans on making any more 2.12 releases.
The current unstable release is 2.13.14. This version has 14 known Critical issues, with probably twice that number of unknown critical problems. We do not recommend that normal users engrave with it.
A common question in open-source projects is "when will the next stable version be released?"; the typical answer is "when it’s ready". LilyPond is no exception: 2.14 will be out when the number of Critical issues reaches 0, and stays at 0 for two weeks. When will that happen? Well, it will happen when these issues are resolved. Items are resolved by contributors working on them. The more work people do, the quicker issues get resolved.
Unfortunately, most of the current Critical issues require attention from experienced developers; any helpful users trying to jump in right now would only delay matters. However, issue 989 (ensure that no information is only in the regtests) could benefit from helpful users.
What does this entail? Well, you need to look at all the lilypond
syntax inside a regression test (a short piece of testing code).
Then you need to check that this syntax is included in the
documentation. In most cases, you can just use your general
knowledge of lilypond — the docs obviously explains
cis'4., so you don’t need to literally find each
portion of that syntax in the docs. However, if the regtest uses
little-known syntax or new features, the documentation might not
reflect this. We have a large number of regtests, so it would be
great if we could divide them between 5-10 people!
(Please feel free to contact Valentin if you’re interested.)
— Graham.
News from the Frog Pond
The Frogs are ordinary LilyPond users who have chosen to get involved in their favorite software’s development. Fixing bugs, implementing new features, documenting the source code: there’s a lot to be done, but most importantly: this is a chance for everyone to learn more about LilyPond, about Free Software, about programming… and to have fun. If you’re curious about any of it, then the word is: Join the Frogs!
In the past several months, most Frog activity has been concerned with guitars.
Back in 2009, our Italian contributor (and Free Software activist) Federico Bruni noted on his blog how fast LilyPond’s support for tablatures was improving:
Now also the modern musician who needs tablature will be able to use LilyPond easily and enjoy the good-looking of TabStaff. I guess this will open the doors of LilyPond to many new users. […] Marc Hohl, an expert user of the LilyPond community, committed himself to creating a configuration file which allowed any tablature user to get the desired output without being forced to tweak the source file each time. Since the last spring he has submitted his changes to the users’ testing and expert developers’ assessment, until a great result was achieved.
I do thank a lot Marc Hohl for the great work and the patience shown in answering the questions and requests from users, who often ask for the most weird things
.
By the way, there is now a specific mailing list for tablature users: http://lists.lilynet.net/tablatures/
And yet, the situation has improved again since this blog post: for instance, hammeron and pulloff are now supported as well, and bends implementation is on its way, thanks to the huge amount of work provided by Marc.
Ian Hulin has also fixed an old (and quite annoying) bug about tuplet brackets.
More importantly, the Frogs have spent a lot of time discussing LilyPond architecture, debugging techniques, improving the Contributor’s Guide, and generally laying the foundation for future contributors. Judging from the number of posts that I don’t understand, the Frogs are definitely learning advanced parts of LilyPond programming!
— Graham.
LilyPond’s companions
Reviewing Frescobaldi
by Valentin Villenave.
Feeling lighthearted again, I decided that the time had come for something I hd been meaning to do for a long time already: give Frescobaldi a proper review!
- History
Frescobaldi is a LilyPond-oriented text editor for KDE4. It has originally been intended as a plugin for the Kate editor, for KDE3 then for KDE4 when it became widely used. Frescobaldi is now developed as an independent program, albeit deeply integrated into the KDE desktop environment. It has its own website, in English and Dutch; Frescobaldi itself is well localized, and supports no less than ten languages!
- Author
Much like LilyPondTool, the other easy-LilyPond-editing environment of choice, Frescobaldi is essentially a one-man work. Wilbert Berendsen is a well-known contributor of our project, and is responsible for the Dutch LilyPond community. Wilbert is also an organist, teacher, editor, composer, conductor, performer (if I understand well, he’ll be giving a concert in a few days). His website is quite interesting, and contains some scores and recordings; I particularly like this short piece by Louis Vierne.
- Development
Unlike LilyPondTool, where many features and graphical widgets had to be implemented (almost) from scratch, Frescobaldi uses the KDE libraries, glued together in Python using PyKDE. As a result, it has a very nice, professional look (did I mention how fond I am of KDE4 ?).
This is particularly visible when comparing, for instance, Frescobaldi:
… with the Kate editor:
As you can see, the text-editing part looks basically the same.
- Installation
From what I can tell, Frescobaldi is relatively well-known in the KDE community (with an 85% rating!); as a result it is available in most major distributions and you may not have to compile it from source (which is, by the way, not a particularly pleasant experience for any KDE app, as it requires installing hundreds of megabytes of -devel packages, plus cmake and the like).
Interestingly, the Frescobaldi packagers for my distribution (Funda Wang & Frederik Himpe) didn’t specify LilyPond as a dependency, and that was a smart move: this leaves me free to download and install whatever LilyPond version I want, be it the stable, development branch, or even a home-compiled git source.
A couple of clicks is all it took for me to find myself with Frescobaldi installed, and listed in my menu under "Sound&Video" (go figure). The very last version (1.0.2) had been released just a few days ago, and yet my distribution’s repository had already been updated.
- Interface
By default, Frescobaldi opens with a very minimal text area. When you’re used to KDE, your first reaction will probably be to look at the vertical tabs on the left and right borders, that actually are retractable panels.
The left panel gives access to a number of articulation marks:
On the right, you may notice a "LilyPond" button. Clicking on it immediately opens two things : a terminal emulator at the bottom, and a PDF-preview panel on the right. KDE’s PDF engine is used here (like in the Okular reader), whereas LilyPondTool has to rely on the JPedal library, that Bertalan had to debug on his own. One minor downside though: there aren’t any buttons/icons/toolbars in Frescobaldi’s PDF-preview panel (let alone LilyPondTool-exclusive features such as PDF ruler or reverse point-and-click), so you better have a scrollwheel if you want to zoom it…
Unlike in jEdit/LilyPondTool, you do not have to save your source code first (and carefully give it a .ly extension). Frescobaldi is obviously meant to work "out of the box", and does indeed a great job at it: similarly, I did not have to manually specify the full path to the LilyPond binary.
At the bottom of the window, a few tabs (that I missed at first) allow you to open a terminal (just like in Dolphin,, KDE’s file manager), consult the log (if any), and… record music using Rumor!
Unfortunately, I did not have the necessary tools to properly test this feature. But its interface sure looks attractive.
- Documentation
The right panel contains another tab: that’s the online documentation browser. Where LilyPondTool embeds its own copy of the docs (with a very useful documentation browser that includes a search function), Frescobaldi, once again, takes advantage of the KDE libraries by embedding a web browser (the same engine as Konqueror).
This might come as a disadvantage though, as you will need an active connection to be able to browse the docs. On the plus side, this ensures that you will always have access to the latest docs build. But then again, there’s still room for improvement: the browser points to the stable Documentation by default (which might be fine), but surprisingly enough, users are not offered with an option to change the URL (for example to use the latest development documentation, or an offline doc-build instead).
Another annoyance, that Frescobaldi is certainly not to blame for, is that the language detection didn’t work, so foreign users may have to use the documentation and website in English by default.
Frescobaldi itself comes with its own offline handbook, like LilyPondTool (though Frescobaldi’s may be a little more newbie-oriented).
- Text editing
As we’ve seen, Frescobaldi relies on KDE’s Katepart component, and therefore has a smooth and pleasant look-and-feel when it comes to source-code editing. Blocks folding/nesting is beautifully indicated with a color gradient:
Unlike in LilyPondTool, not only { ... } blocks are indented, but << ... >> blocks as well:
Context-sensitive autocompletion and highlighting is well supported: here are a few examples…
UPDATE — In LilyPondTool the autompletion is actually more fine-grained, since it will only show the possible properties in an override. However, syntax-highlighting looks better in Frescobaldi for now.
Scheme syntax-highlighting is simpler, but better-handled than in LilyPondTool (where, for instance, Scheme keywords aren’t highlighted only in Scheme blocks). Still, I somehow prefer LilyPondTool’s indenting and folding when it comes to Scheme code (but it’s probably a matter of habit — and taste: Kate’s brownish coloring of Scheme isn’t very pleasant).
Like LilyPondTool, Frescobaldi features customizable code expansions:
- Wizards
Frescobaldi includes a Score Creation Wizard, that very much resembles LilyPondTool’s… but with a twist.
The first window looks exactly like LilyPondTool’s… but if you look closely you’ll notice that the preview "image" (that is precisely not an image, in Frescobaldi’s case) is better centered… and even localized! How nice.
The usual list of instruments (aka "let’s pretend we’re Sibelius for a while"). Where LilyPondTool sports a three-pane interface, Fresco only uses two (with submenus), and adds specific options on the left.
Here’s the twist: once you have chosen your options, you are presented with a preview of your settings! I have to confess that at this point, my jaw dropped and the only thing I could say for a while was :
woooooooow…
- Gizmos
We already mentioned the "Insertion" panel that allows to quickly add articulations to your music. This certainly looks nice, but one could argue that having to use the mouse to add articulations is hardly quicker than using the keyboard. Most users would probably prefer to assign keyboard shortcuts to these functions. LilyPondTool has also such buttons, but in a drop-down submenus, which is less convenient but preferable from a screen-real-estate point of view.
In this "quick insertion" panel, I was surprised not to find a way to quickly add slurs, phrasing slurs, or manual beams. This seems way more useful than adding \rheel or \lheel indications — but perhaps it’s because the author is an organist 
Finally, let’s note that this feature is not context-sensitive. It is smart enough to leave rests alone and deal with compound durations such as cis2*5/8, but doesn’t identify comments or \lyricmode blocks, nor does it take the notenames language into account.
There are a couple of nice and convenient unique tools. For instance, in the "Pitch" submenu, an option allows you to change the language used throughout your source code. Nothing extraordinary, but it’s welcome nevertheless.
Another one, possibly my favorite: a well thought-out wizard allows you to easily create blank staff paper!
Once again, there’s even a preview:
- Conclusion
Such features make Frescobaldi not just a nice toy to play with, but a considerate editor that has obviously been designed by someone who actually writes music. Wilbert has cleverly used all the power and flexibility of KDE4, and that amounts to a very slick software with an irresistible "wow" effect. I did have seen some screenshots on the website, I had even contributed to Frescobaldi translation, and as someone who’s generally used to testing bleeding-edge software, I really wasn’t expecting to be impressed. Yet here I am.
One can but regret that this beautiful software actually targets a very narrow range of users: people who run KDE4 (that’s between a third and a half of all GNU/Linux users). For these users, Frescobaldi is a treat already; for example, I could perfectly imagine a classroom full of Free-Software-driven laptops running Frescobaldi. Unfortunately it’s a far cry from supporting people who need such software most: that is, Microsoft Windows hostages users.
KDE4 is known to be theoretically portable to this system, so one could imagine building Frescobaldi for Windows. Unfortunately things are a bit complex: from QT4 that run natively without a glitch on Windows (SMPlayer), to KDE4-tied apps that require hundreds of megabytes of dependencies (Amarok), I’m afraid we’re not there yet.
One last word about Frescobaldi compared to jEdit/LilyPondTool. As you may have noted, I’ve been familiar for a long time with this later environment. Does this review of Frescobaldi make me want to switch? Well, although I do have considered it at some point, I think I am going to stay faithful to my ugly/bloated/Java editor of choice.
Not because of the numerous features it has, which Frescobaldi does not (reverse point-and-click, real-time syntax parsing, virtual piano, MIDI player, offline docs, PDF ruler, etc.) — I have hardly ever used these features, and do not see the need for them.
Not because it’s multi-platform: from now on I won’t bother running anything else than KDE4 GNU/Linux. Not even because I designed its new icons
But more for a sentimental reason: LilyPondTool and I go way back, and I have seen its progress, I have seen Java become Free, I have seen Bertalan add new features one after another, fixing bugs, in a much less developer-friendly context than what KDE4 provides. I have taught generations of students how to install and use it, I’ve even made video tutorials about it.
Just like the old laptop I’m using to write this review: it’s ugly, tired, I’ve changed almost every parts of it myself over the years. But while I can appreciate a beautiful and powerful computer whenever I see one, it’s the story behind it that counts. That being said, I hope this review will give some readers the curiosity to give Frescobaldi a try, and, who knows, perhaps they’ll make their own story with it — and if you do, please do tell us: we all love stories!
— Valentin.
Bug Report of the Report
Our favorite bug report from these two months came from Roman Stawski:
This short polyphony employs A trivial customised Voice but the lyrics ignore the first note in the score — that’s not the behaviour of choice.
As it happens, it turned out to be another instance of an existing issue. But the creative poem was definitely appreciated!
— Graham.
… Aaand this concludes the seventeenth issue of The LilyPond Report.
The next instalment will be published on Saturday, May 2010 the 3rd.
Cheers,
Graham Percival & Valentin Villenave.
