Nearly five months ago I claimed to be making “rapid progress with language learning”. Well obviously not rapid enough to actually reveal anything. Well that might be at an end soon.

One of the problems of writing the app using things like LINQ means most people will have other things to install to use the app (.NET 3.5 specifically – and possibly .NET 3.0 for non Vista users) and even then it’s limited to Windows users as Mono support for Windows Presentation Foundation will be a long way off (if they do it all). Since Silverlight 2.0 is supposed to be really cool and now supports a big chunk of the widgets from standard WPF (and has has quickly developing Moonlight support), why not write the app in that?

So that’s what I’ve been doing.

And it was a lot easier than I thought. The first piece of easiness I found was that I oly had to make like three changes to my non-UI code to make it compile as a Silverlight DLL. Unfortunately I can’t persuade Visual Studio to compile it as a Silverlight DLL and a normal DLL in one go, so I’ve currently got the same code added as two different projects and I copy the code between them (not ideal). The only real work I had to do was reimplement my data provider. When I started, I cunningly made sure that all resources (lessons, media, user progress) was grabbed from a data class. I wrote a new class that fetches it from a RESTful server (more on that in another post).

So hopefully, a nice Silverlight version of the app will be public soon…

About Silverlight
For those that don’t know, Silverlight is Microsofts answer to Flash. Apparently. I’m not sure if it’s that a good analogy really. Silverlight 1.0 basically gave you access to a nice environment to draw things in the browser and then manipulate it with Javascript. Or something. To be honest I didn’t really care about version 1.0 since writing complicated things in Javascript doesn’t sound like fun. Silverlight 2.0 (formerly Silverlight 1.1) on the other hand gives you that same environment but the ability to manipulate the things with compiled .NET assemblies written in any CLR language and comes with implementations of a lot of the widgets in the WPF.

Recently I started using it to plan lessons for the language learning app. The ability to use it from work (or any other computer I might be on – including viewing it on my Nokia 770) was useful, but in the end I was only really writing a list with it. Until now.

I now have a nifty little C# app that generates modules directly from a Google Spreadsheet which is definitely a Good Thing. I’ve been thinking of writing an app for module editing for a while since writing them by hand is tiresome and error prone. Google Spreadsheets does half the work for me by providing the user interface for generating a table and then provides access as simple XML.

Which brings me to the matter of actually accessing the data. Google provide a client library in C# for accessing quite a lot of their API. I tried using it but found it a little confusing. Luckily since I was just wanting to query data, I discovered that raw access was actually easier. You simply make a GET request to
http://spreadsheets.google.com/feeds/worksheets/key/public/values (where key is provided to you when you “publish” a spreadsheet – access to unpublished spreadsheets requires authorization which is more complicated). This gives you an Atom feed of URLs to the individual worksheets which them contain Atom feeds of either rows or columns (your choice).

The query power of LINQ (along with XElement, XAttribute etc.) make transforming the feeds into modules really easy. In fact the code that does the hard work (takes a spreadsheet key and generates the XML) is only 102 lines long, and that’s including unnecessary spacing to make the LINQ more readable (the main LINQ query is 35 lines).

The sample MP3s should be available “soon”…

Part of the design philosophy of my language learning app is to reuse as much as possible. This brings up an interesting issue regarding regional variations of languages (I’m talking mainly about somewhat standardised variations) and how much should be shared between them.

For example in Belgium, French is an official language. This is almost the same as French as spoken in France but with a few important differences. Firstly there are minor vocabulary variations (Belgian French has specific words for 70 and 90 for instance). There is also a lot of Flemish and Walloon vocabulary used in addition to the French vocabulary. Finally there are pronunciation differences but these seem no greater than differences in accent.

So, a course on Belgian French should be almost identical to a course on Standard French. The question is how to notate that in the script files the language app uses.

There are basically three ways I’ve come up with to cope with the situation, and I think I’ll support all of them since they have different advantages in different situations.

The first is to allow in line region specific phrases. So for the numbers in Belgian French, the standard French files would be used but any Belgian French sections would take priority.

The second is to have whole region specific files. Extra Belgian phrases not appearing in standard French would be in these and be loaded in addition to the standard French files. This is really an extension of the first.

The final case is no link at all. This would be needed for Chinese. The language code for Mandarin is “zh-guoyu” and the code for Cantonese “zh-yue”. In this case however there is no such spoken language with the code “zh” and therefore nothing to inherit from. This is an specific case of the first two where no parent language exists.

So far this has just been considering audio. The app already supports text and will eventually support text only lessons of some sort. The first method above could be using for spelling variations (when learning English “color” and “colour” could use the same audio while appearing differently on the screen). As more dramatic example Serbian could be taught using either the Cyrillic alphabet or the Latin alphabet with the codes “sr-cyrl” and “sr-latn” respectively. Or perhaps even both…

The final point I want to make regards the actual audio files themselves. Although it is true than most of spoken French is almost the same in Belgium and France, the accents are different and generally identifiable to French speakers. Therefore regional specific audio is desirable where possible. Since the script files and the audio are kept separate this is is possible with the language app. If the Belgian French audio exists that will be used, if not the standard French is used. That means that if a standard French course is created, an adequate Belgian French course can then be created with little effort but with the possibility of improving it later

The main reason for changing is simplicity. I had a look at the TreeView control in Gtk and decided it was too much work. Although the theory of good MVC separation is good, the user interface is such a small, simple part of my app it wasn’t worth it. The stuff I need from System.Windows.Forms should work in Mono (and .NET 1.1 and hopefully even the Compact Framework).

I still prefer the way Gtk handles layout of controls in general, but I console myself with the Windows form designer in Visual C# Express…

You see I recently started a large project in C# at work (a desktop app by the way, not ASP.NET) after saying I was somewhat familiar with it and it should be easy to learn. The good news is after two days I realise it actually is really easy to learn, providing you let it do the work for you. (To any programmers intending to learn it, you’ll spend most of your time at first not actually writing code but finding whereabouts in the huge class library the functionality already exists is. Once you get used to it and get the hang of how it works it is surprisingly relaxing.)

Despite all that I decided I still needed some practice in it so I came up with the idea of doing the language learning app as a fully fledged desktop application – although at work I’m using System.Windows.Forms I’m using Gtk# so it can hopefully run on Mono (and therefore Linux, Mac OS etc). The biggest problem I have is actually playing the audio. A quick search for “C# MP3″ comes up with a solution based on MCI, some clever thing embedded in a Windows DLL that obviously won’t be cross platform. My workaround at the moment is just use an external program via the command line that I suppress the window of. If anybody knows of a better way that would work on .NET and Mono, let me know…

Mono, C#, .NET, language learning, Linux, Gtk, winforms, MP3, dot net

One of its oldest sister projects, Wiktionary on the other hand is not so good. I think it’s a marvelous idea that should be done and should definitely continue, but at the moment it is frankly a mess.

In case you don’t know what it is, it’s an attempt to create a free multilingual dictionary in every language. That is not a tautology – I’m emphasising the fact that it aims to translate from every language to every other language. That is the English version will contain every single word in every language with definitions and details in English. The German version will do the same but with definitions and details in German. And so on for every other language. Of course for some languages there will never be enough editors (English probably has the most and that’s nowhere near complete).

Ambitious. Possibly too ambitious. The number of editors doesn’t seem to be as high as Wikipedia and editing is far less fun – there is far more grunt work to do with laying out tables, sorting out headings, getting links pointing to the right places. There are quite a few bots which can automate some of it, but it’s still a large and largely dull undertaking.

Why am I telling you this? I don’t know. Maybe just to encourage a couple more editors to jump on board :)

So, I’ve created an engine for finding language learning resources. And it’s surprisingly good.

In the meantime I’ve reading about XMPP, the protocol used by Google Talk and several others. One of the extensions that Google is largely responsible for Jingle which essentially allows voice communications. There are also a couple of XMPP clients written in PHP. So it may be possible to deliver lessons over XMPP through a chat bot.

At the moment it plays the audio at you without anything on the screen. Perhaps the screen could display explanations of interesting or important points about what you hear? I’m worried about distracting people from listening and limiting the offline usability of precompiled lessons though…

Pimsleur, polyglot

I bring this up now because Julia made a wonderful example of an incorrect collocation for English. She came up with the phrase “two and a half hundred”. In English you can say “two and half thousand” and “two and half million” but for some reason it doesn’t work with hundreds (it does in Finnish incidentally).

Finnish, linguistics, collocation

Basically when learning, you pay per phrase (phrase in this context means any named element. Usually a phrase but could also be a specific term). The cost would be something really low (say for example $0.01 each). You only pay for a phrase once regardless of how many times it gets repeated or how many conversations it appears in. Just to provide some sort of concrete example, the material I’m testing with (which covers the first two Pimsleur lessons) has 82* different phrases/terms. Quite a few simple conversations can be put together with that material. As the number of phrases increases, the number of conversations increases exponentially (the mathematician within me has to point out that strictly speaking it’s probably not exponential).

The clever part would be to allow people to upload their own audio. Although this has a few issues with regards to quality it might work. If you upload audio, you get a percentage of the money spent on listening to your audio. What the exact percentage should be is complicated though. As well as audio, the other big part of the system is the scripts. The traditional part of me feels that the scripts should have some sort of professional input from someone with experience teaching the language. Another part of me realises that hundreds of books exist for teaching languages that are written by professionals that are totally useless (and therefore professional input may not be all its cracked up to be). With that in mind, someone fluent in the language may be all that is required. Either way, the script writers need money too and should probably get a percentage as well. That $0.01 is being spread quite thin…

The system obviously needs an infrastructure in place to sort this. At a basic level it should list phrases that are needed in scripts but are missing. Another part would be to highlight underutilised phrases that need more conversations writing for them.

As a final note I’d like to explain another bit of cleverness in the system (and an associated problem, perhaps). Before a conversation is played it is checked for completeness – i.e. do sound files exist for all the required audio. Shortly I’ll be adding another layer to this – checking for sound files by the right people. Phrases in a script are marked by “person”. Simply a way of identifying who is doing the talking when a script involves more than one person (which most of them will do). It’s important that all elements in a script marked “Person1″ are by the same person and all the parts by “Person2″ are by the same person (and that “Person1″ and “Person2″ are different from each other). This means that there will be some duplication of audio going on. If someone records all the initial audio, but then never records any more, someone else will have to re-record most of it since it will be used in later scripts. Which also implies there’s nothing to stop people re-recording the initial material in an effort to get a percentage of the money (assuming enough is offered to make it worthwhile). I’m not sure if that really is so bad though – it offers more variety for listeners…

* Or perhaps 164. Whether you should pay for the native and foreign versions is a tough subject. I’d like the application to be independent of a specific language so my preference would be “yes”. They take just as much effort to record after all…

Pimsleur, language learning, voice talent, foreign language

The best thing to do perhaps would be to avoid trying to be Pimsleur quite so exactly.

I have a series of phrases I need recording with a total audio time of about five minutes. I need them in as many languages as possible (although if it isn’t English, German or Finnish then I’ll also need them translating – they are really simple by the way). My main requirements are that the recording is good quality and that you are a native or fluent speaker of the language.

After looking around the Internet for a bit I discovered I could technically afford the hourly rate of most voice actors marketing themselves on the Internet – except they all had rather high minimums which made my five minutes very expensive (although I realise five minutes of audio takes more than five minutes of work). As well as money I can also offer a link and a review which has to be worth something (after all people are paying me for links that have nothing to do with the content of the site and presumably think it’s worth it).

If you’re interested, email me with the language(s) you could do and a quote (and preferably a sample but I acknowledge that this approach is hardly targeting professionals).

voice talent, voice actors, German, Finnish, French, Spanish, Italian, Pimsleur

My language learning app uses the Zend Framework and so uses pretty URLs by default. I need the interface available in many languages, but then the URLs should be pretty in a localized way.

For example, starting a new Finnish lesson uses the following:

/lesson/new/fi

That would be the new action of the lesson controller with an extra language code parameter of fi.

In German this should be something like:

/lektion/neu/fi

By default this would access the neu action of the lektion controller.

The “simple” solution would be to write lots of controllers that just delegate to the real one. Which is silly. Instead an extra layer has to be added to the routing process some sort of look-up table mapping localized URL fragments with “real” canonical ones. This should be fairly simple with Zend Framework (although I haven’t actually tried yet).

Just an important issue no-one seems to have brought up yet…

pretty URLs, Zend, Zend Framework, web frameworks, MVC