Syndication

[Tag search]

I found an interesting problem while working on a test case generator
for the Tsukurimashou Project.
The thing is that I'd like to assign an identifying code, which I will call
an address, to each line of code in a code base. It's to be
understood that these addresses have nothing to do with machine memory
addresses, and they need not be sequential; they are just opaque entities
that designate lines of code. Anyway, I would like lines of code to keep
the same addresses, at least probabilistically, when the program is
modified, so that when I collect test information about a line of code I can
still keep most of it after I update the software.

I have just posted Tsukurimashou
0.9, the latest version of my Japanese-language font project.
After almost a year in development since the last version, this one contains
1754 kanji, including all through Grade Four and 100 from Grade Five (a
little more than half of the 185 assigned to that grade). This version also
includes extensive infrastructure changes, most notably a bundled
interpreter for the FontForge native scripting language, intended to provide
insurance of future support as mainline FontForge moves further and further
away from that language.

The future of Tsukurimashou development may be tangled, as my commitments
and priorities change with my upcoming move to Denmark. This 0.9 release was
produced in a bit of a rush to get something out the door before I pack up
my computer for shipment. I don't know when I will next get a change to
work on it more, but that will be at least two months from now. You can do
your bit to support continued work on Tsukurimashou by building it, using
it, and above all by writing about it. What the project needs most of all
is attention.

FontAnvil is a script language interpreter for manipulating fonts.
FontAnvil is substantially compatible with the PfaEdit/FontForge native
scripting language, but FontAnvil is intended for non-interactive use; for
instance, invocation from the build systems of font packages like
Tsukurimashou. To better serve font package build systems in general and
Tsukurimashou in particular, FontAnvil has no GUI and, to a reasonable
extent, avoids dependencies on external packages.

I've posted Tsukurimashou
0.8, the latest version of my Japanese-language font project. This
version contains 1502 kanji, including all through Grade Four. There are
relatively few infrastructure changes for the fonts in this version, but Kleknev is new in this release
(still at alpha status) and IDSgrep
0.4, released a few days ago and included in this package, contains
some new and exciting speed enhancements.

UPDATE: I presented Tsukurimashou at TUG 2013 in Tokyo this October.
You can read my
slides (PDF file) on the conference Web site, and see some
photos from my trip in my photo gallery. The paper will appear in
TUGboat 2013.3, which will be posted on TUG's Web site
(initially members-only, eventually open-access, or visit your library) in
the near future.

When I was preparing the Tsukurimashou 0.7 release, I
had to build the entire package several times from scratch, to verify that
all the necessary pieces really were included in what I was preparing to
ship. When I run the build on my development machine it normally re-uses a
lot of previously-built components, only updating the parts I have recently
changed. That kind of incremental compilation is one of the main functions
of GNU Make. But if I'm shipping a package for others to use, it has to
work on their systems which don't have a previous history of successful
builds; so I need to verify that it will actually build successfully in such
an environment, and verifying that means copying the release-candidate
package into a fresh empty directory on my own system and checking that the
entire package (including all optional features) can build there.

Tsukurimashou is a big, complicated package. It's roughly 92,000 lines
of code, which may not sound like so much. For comparison, the current
Linux kernel is about 15,000,000. Tsukurimashou's volume of code is roughly
equivalent to an 0.99 version of Linux (not clear which one - I couldn't
find numbers I trusted on the Web just now, and am not motivated to go
downloading old kernel sources just to count the lines). However, as
detailed in one of my earlier
articles, Tsukurimashou as a font meta-family is structured much
differently from an orthodox software package. Things in the Tsukurimashou
build tend to multiply rather than adding; and one practical consequence is
that building from these 92,000 lines of code, when all the optional
features are enabled, produces as many output and intermediate files and
takes as much computation as we might expect of a much larger package. A
full build of Tsukurimashou maxes out my quad-core computer for six or eight
hours, and fills about 4G of disk space.

So after a few days of building over and over, it occurred to me that I'd
really like to know where all the time was going. I had a pretty good
understanding of what the build process was doing, because I
created it myself; but I had no quantitative data on the relative resource
consumption of the different components, I had no basis to make even
plausible guesses about that, and quantitative data would be really useful.
In software development we often study this sort of thing on the tiny scale,
nanoseconds to milliseconds, using profiling tools that measure the time
consumption of different parts of a program. What I really wanted for my
build system was a coarse-grained profiler: something that could analyse the
eight-hour run of the full build and give me stats at the level of processes
and Makefile recipes.

I'm very happy to announce the release of version
0.7 of Tsukurimashou, my Japanese-language font project. That is a
link to the release page for the source code package on SourceForge.JP; see
also the complete list
of downloadable files and the project home page. This has
been almost nine months in the making, and as I said on Twitter, the yak
hair is thick on the floor. Release notes below the cut.

At long last, I've completed the 0.6 release of the Tsukurimashou fonts (project home page). This one contains 1110 kanji, including all those taught in the Japanese school system through Grade Three. Also new in this release are experimental italics and integration with my IDSgrep structural-query software (which has its own, separate release series). Downloads: source code; precompiled fonts; demo PDF files.

I went through a bit of a crunch to get Tsukurimashou 0.5 out the door before my year-end vacation. With that done, and at least 99 kanji to do before the next planned release, I have a chance to sit back and think about some longer-term and spin-off projects. Here are some ideas on kanji searching.

UPDATE: A prototype implementation of the system described here now exists as part of the Tsukurimashou project, and you can check it out via SVN from there. Packaged releases will be available eventually.

I've released a new version of the Tsukurimashou fonts (project home page). This one contains 776 kanji, including all those taught in the Japanese school system through Grade Two and half of Grade Three. The bigger news, however, is that I've also added a set of fonts for the Korean hangul writing system. Those should now be beta quality - you should now be able to write the standard modern Korean language in its entirety. Downloads: source code; precompiled fonts; demo PDF files.

These fonts are far enough along now that I'd really like to create a bit of "buzz" around them; that's part of the sneaky plan behind my recent technical postings about my experiences building the fonts. I'm hoping that a lot of people will read those, and, especially, share them on systems like Twitter and the other one. In the new year, after I've posted a couple more (I'm aiming for weekly technical postings), I'll evaluate whether they are attracting third-party traffic and whether I want to continue them. They take up time I could be spending on writing code, but having people use the software is important too.

Here are some thoughts on the Tsukurimashou build system. You can find the code, and some documentation of how to use the build system, in the package, but this posting is meant to look more generally at some of the issues I encountered while building a build for something weird.

The thing is, Tsukurimashou isn't a piece of software in the normal sense, but a package of fonts. It's written sort of like software, using programming languages, but the data flow during build doesn't look much like the data flow during build of the usual kind of software package. As a result, although it seemed like using Make was the thing I wanted to do, the way I've written my Makefile doesn't look much like what we might expect on a more typical software project. Working on it has forced me to see the structure of the project quite differently from the way I'd usually look at software, and maybe some of the ideas from that can be applied to other things.

I encountered an interesting problem on the Tsukurimashou project recently, and some inquiries with friends confirmed my suspicion that if anyone has solved it, they've done it in a language-specific way for ridiculous languages. It appears I have to solve it again myself. Here are some notes.

This is an announcement for an outdated version. More recent versions are available; see the Sourceforge project for the latest one.

I'm very happy to announce a new release of the Tsukurimashou font project, version 0.4. See files from this release on the Sourceforge releases page, and the summary for the project. The current glyph counts are 2021 overall, 573 kanji; this version now includes all the grade-school kanji through Grade Two. あなたもは、７歳みたく書きことができますよ！ (You, too, can write like a seven-year-old!)

I've just posted the second release of the Tsukurimashou font family - now with 198 kanji, including the 80 Grade One jouyou kanji. You, too, can write like a six-year-old! Also new in this version is a fancy build system.

Download the source package (ZIP) which includes four ready-made OpenType font files, or preview it by looking at the demo PDF (which is not much changed from last version) and the kanji chart.

More commentary probable at some future date; for the moment I've already used up today's word quota writing the package documentation.

I'm pleased to announce the first release of the Tsukurimashou font family. The user's manual and demo is available as a PDF file; so is the complete package in bzipped TAR and ZIP formats. Precompiled OpenType fonts, compatible with all currently-popular typesetting systems, are included in those packages for two styles (Tsukurimashou Kaku and Mincho). Other styles you'll have to compile yourself.

These fonts are released with source code under the GNU GPL version 3 with font-embedding clarification. The current version contains the full repertoire of ISO Latin-1, hiragana, and katakana; more characters are on the way.