Javia blog

My newest application, Javia Calculator,
is available for early-access download; go try it out while it’s hot.

Javia Calculator is (you guess!) a calculator for mobile phones (requires CLDC-1.1).

Well, one more calculator… but one won’t stay in your way when you’re trying to get the result.

It features trigonometric functions, logarithms, user-defined functions and constants, history navigation, implicit save, and an efficient input method.

Here I show why the .org TLD will grow in standing and reputation, eating from .com’s domain market share.

TLD means Top Level Domain, such as .com and .org.
CC-TLD means Country Code TLD, such as .de and .uk.

(source)
This graphic shows the evolution of the total number of domains, per TLD, in time. From the last column, which shows the situation in august 2006, we can see that the biggest (in number of domains) TLDs are, in this order: com, de, net, uk, org, info, eu.
If we consider only the unrestricted, global TLDs (and excluding .info), we are left with this order: .com (50 million domains), .net (6 million), .org (4 million).

So .com is the main TLD, this is well known. But how to choose between .net and .org? Suppose you want to buy a domain name, and it’s not available in .com, but it is available in both .net and .org, and you want to buy it only once. What should you choose? My take is: choose .org.
Why?

While both .com and .net are operated by Verisign, .org is operated by Public Interest Registry. Verisign is generally viewed as the big bad company who makes all the money from the domain business. Between the two registries, I’d choose PIR.

But this is not all: .org simply sounds better than .net, because of the more vowel-like, round sound. It generally composes better with names ending in a consonant. Compare: menstral.net and menstral.org, I find the .org variant nicer. On the other hand, .net has the side of the omonimous Microsoft platform .NET, which perhaps has some positive impact on the number of .net domains. At least all the sites related to MS .NET would perhaps choose a .net domain over a .org one.

.net is generally viewed as the shadow of .com, the second-class .com, the .com of the poor people. That’s why many people see it as the second-choice after .com. And as .com, .net has a rather commercial connotation. On the other hand, .org has a distinct sound, originating from its association with ‘organization’. It offers the connotations of ‘community’ and ’social’. There are many businesses who deliberately chose .org over .com, the premier example being OpenOffice.org. In general, the community-oriented and the open-oriented sites would favor .org over .net. Because of these reasons, .org is gradually accumulating a better reputation than .com and .net on the web, some king of a friendlier, welcoming sound: we’re here to help, not to rip you off. But above all, the main reason for the .org rise in importance will be this self-fulfilling prophecy (just joking).

The problem with .com is the domain-spammers, or domain-bandits. They grab large amounts of domains (in the range of millions of domains), and put on them pre-made advertising pages, with no real content, with the sole intent to trick the users into clicking the ads. The situation is so bad that perhaps as much as 80% of .com domains are such obnoxious ad garbage. This is why it’s so hard to find an available useful domain in .com. This domain-pollution affects all the TLDs, not only .com, but .com is the main target because it’s perceived as being the most valuable TLD. On the other hand, as the pollution gets worse, at some point same action will have to be taken to keep the whole domain name principle working, similarly to the way email-spam, threatening the email usability, is prompting active measures.

In the mean-while, what will happen is that .com will increasingly become the domain of spammers (who are good and quick at grabbing any name that’s possible to get), while the legitimate new web sites will increasingly choose either a CC-TLD or one of .org and .net.

What about .eu? Unfortunately, .eu combines the worst features described above: it is mainly a spammers’ domain too (because of the botched launch by eurid), and at the same time it is a minor domain, much smaller than .de or .org. What’s more, it is limited to EU registrations. On the positive side, the price of .eu will decrease following the price reduction from 10e to 5e by eurid.

What about .info, .name, .biz, etc? These are minor and will perhaps never take off. The four-letter TLDs are a particularilly bad because they add one letter to the length of the domain name, without offering any advantage in exchange.

What about .mobi? IMO we should boycott this TLD, not buy it at all, because it is based on the wrong idea of a TLD, as it goes against the one-web principle. And it’s overpriced. And it’s a 4-letter TLD. I’d keep out of it for now, thanks. I hope the failure of .mobi will be a lesson for those trying to artificially impose not-needed domains. Like, why buy just one domain, when you could buy ten?

In general, I think the importance of domain names will continue to diminish, as more and more traffic is directed by search engines as opposed to users typing the URL in the browser. And I’m looking forward for a solutions to the exploding domain-spam business.

And these are all the domains I own:
francuski.com
frumos.com
javia.org
javia.eu
menstral.net
menstral.org
procod.com
proverbe.org

This is a topic I posted on the Mobile and Embedded forum:

There is a need among midlet developers for a ‘phone emulator’ which runs in a (desktop) web browser. This would allow the developers to demo their midlets on the web, and allow the users to try/test the midlets before installing them on their mobiles.

A first choice is for the emulator to be a JavaSE applet, which runs in the browser.

Developing such a ‘phone applet’ is roughly equivalent to having a MIDP (and additional API JSRs) implementation over JavaSE.

Can phoneME-feature be used to develop such an applet?

And could JavaSE be considered as a possible new ‘target’ for phoneME compilation (in addition to Linux/arm, Windows/i386, etc)?

In my understanding, I would see JavaSE replacing the CLDC level in a phoneME/SE target. In this case, the porting (of phoneME) to JavaSE would be different from the typical porting process to a new platform which happens at a much lower (kvm, cldc) level. E.g., because JavaSE already has a java VM, the kvm wouldn’t be needed.

So what do you think about using phoneME to obtain a MIDP over JavaSE implementation? What about a JavaSE target for phoneME-feature?

It’s old news now, since a week (since 2006-11-14) a first piece of JavaME has been open-sourced by Sun under GPL, under the name PhoneME (Mobile and Embedded).

First of all, this is a great move, thanks Sun. The license (GPL) is ok, even though it could have been a more liberal one like Apache, BSD or LGPL.
I think it’s GPL because Sun wanted to somewhat protect its financial investment and commercial license revenews.

PhoneME is the same thing as Sun Java Wireless Client, which is a commercial product that Sun is licensing to mobile device manufacturers. The differences are the name (Sun avoided to use ‘Java’ in ‘PhomeME’) and some proprietary parts that will perhaps be open-sourced later.

The PhoneME-feature contains (from the lower level up):
- a low-level portability layer, PCSL
- the java small virtual machine implementation, KVM
- CLDC
- MIDP and additional API JSRs

PhoneME now supports as targets Linux/i386, Linux/ARM and Windows/x86.

Software development can be seen as an iterative process where each iteration consists of an Expansion followed by a Contraction.

An Expansion consists in implementing new features as quickly as possible. The focus is exclusively on getting the new features to (somewhat) work. This may be seen as a prototyping of the new features, because they are implemented hastily and thus superficially, but quickly. During an expansion the elements that are not directly observable in the functionality being added may be ignored: elegance, orthogonality, consistency, performance, algorithmic complexity, economic data structures, exception condition handling, error reporting, logging, scalability. An expansion consists in getting it to work as fast as possible, but the quick solution may be a dirty one.

A Contraction conserves the existing features, but cleans up the mess. The code is refactored. The redundant parts are removed. The design is pondered and improved. Design orthogonality, consistency, simplicity, elegance are of paramount importance. The behavior in corner-cases (limit, exceptional situations) is carefully analized and tested. Many bugs are found and fixed. The performance (speed, memory usage, etc.) is measured and improved (profiling). More efficient algorithms replace the naive implementations of the Expansion. During a Contraction no new features are added, the externally observable functionality remains unchanged, but the internals are consolidated.

An Expansion shows the developers where the product can go, it gives them inspiration and trust that the difficulties can be overcome. But during an expansion, as the implementation becomes more and more disorganized, the developers get a sense of uncertainty on the code, of gradually losing the understanding of how the things work, losing grip on the code. Forward progress becomes gradually harder, because building on the now shaky foundation is difficult. These are indications that it’s time for a Contraction.

A Contraction makes the developer feel that the implementation is getting clean, elegant, and solid. The developer re-gains control and trust over the code. The code is becoming smaller, streamlined, beautiful, efficient. On the other hand, the observable functionality of the product doesn’t change, doesn’t progress during the Contraction. The result of the Contraction is a clean, solid and trusty base from which the next Expansion can be attempted.

During the Expansion the developer increases the size of the codebase. During the Contraction, he decreases the size of the code. Thus the work of the developer consists in both adding code (the positive, constructive aspect) and removing code (the destructive aspect). Destructive is meant here in a good sense, like burning the extra fat, cleaning the weeds, removing a tumor or sweeping-out the garbage. And I dare say that removing code, that is re-organising the code in a better way while keeping the functionality essentially unchanged, is harder to master than adding new code.

To somebody not involved in the internals of a project, only the Expansion has visible results. From the external viewpoint, during the Expansion the project grows as new functionality is added, while during the Contraction it looks like nothing is happening. It is tempting to direct the team like this: good, you just finished this Expansion, it’s time to start the next Expansion right ahead. Were developers to follow such advice, they would find it harder and harder to advance as the project becomes disorganized, anarchical, amorphic after a series of Expansions with no Contractions.

And a parallel with the bubble: during an economic expansion, there is an abundance of capital and exuberant growth. But the abundent capital drives both good and not so good enterprises, and the affluent ressources are not used efficiently. A contraction is needed to wipe out the lousy businesses, thus freeing the capital blocked by them, and to urge the remaining business to move to a new level of efficiency. The healthier result forms the base of the next expansion.

The gamma function is the extension of the factorial to real numbers (n! == gamma(n+1)), and it’s a very important function in mathematics. Gamma(x) grows very quickly (similar to x**x), that’s why lgamma(), which is the logarithm of the gamma function, is often used instead. In the discussion below, I’m only considering the lgamma(x) on the positive axis (x>0).

I wanted to have an implementation of lgamma() in Java. I studied these four implementation alternatives:

1) The Lanczos approximation using g=7 and 9 terms, which is used in the GNU Scientific Library. Also the sample code in the wikipedia article uses the same parameters (g=7, 9 terms).

private static final double L9[] = {
    0.99999999999980993227684700473478,
    676.520368121885098567009190444019,
    -1259.13921672240287047156078755283,
    771.3234287776530788486528258894,
    -176.61502916214059906584551354,
    12.507343278686904814458936853,
    -0.13857109526572011689554707,
    9.984369578019570859563e-6,
    1.50563273514931155834e-7
};
private static final double LN_SQRT2PI = 0.9189385332046727418; //log(2*PI)/2

static final double lanczosLGamma9(double x) {
    if (x <= -1) return Double.NaN;
    double a = L9[0];
    for (int i = 1; i < 9; ++i) {
        a+= L9[i]/(x+i);
    }
    return (LN_SQRT2PI + Math.log(a) - 7.) + (x+.5)*Math.log((x+7.5)/Math.E);
}

2) The Lanczos approximation using g=607/128 and 15 terms, used in the Jakarta Mathematics Library and described here.

private static final double[] L15 = {
    0.99999999999999709182,
    57.156235665862923517,
    -59.597960355475491248,
    14.136097974741747174,
    -0.49191381609762019978,
    .33994649984811888699e-4,
    .46523628927048575665e-4,
    -.98374475304879564677e-4,
    .15808870322491248884e-3,
    -.21026444172410488319e-3,
    .21743961811521264320e-3,
    -.16431810653676389022e-3,
    .84418223983852743293e-4,
    -.26190838401581408670e-4,
    .36899182659531622704e-5,
};

static final double lanczosLGamma15(double x) {
    if (x <= -1) return Double.NaN;
    double a = L15[0];
    for (int i = 1; i < 15; ++i) {
        a += L15[i]/(x+i);
    }

    double tmp = x + (607/128. + .5);
    return (LN_SQRT2PI + Math.log(a)) + (x+.5)*Math.log(tmp) - tmp;
}

3) The Stirling approximation with 4 terms.

private static final double
    LC1 = 0.08333333333333333,
    LC2 = -0.002777777777777778,
    LC3 = 7.936507936507937E-4,
    LC4 = -5.952380952380953E-4;

static final double stirlingLGamma(double x) {
    final double
        r1 = 1./x,
        r2 = r1*r1,
        r3 = r1*r2,
        r5 = r2*r3,
        r7 = r3*r3*r1;
    return (x+.5)*Math.log(x) -x + LN_SQRT2PI + LC1*r1 + LC2*r3 + LC3*r5 + LC4*r7;
}

4) The lgamma implementation from SUN’s FDLIBM 5.3.
As this implementation is more complex, and notably uses 61 precomputed double constants, I don’t inline here, but you may find it in the full source code.

I was curious which one of these implementations is the most precise, and which one is the fastest.
I computed an “error table” which shows the error of these functions in ULPs over the integers from 0 to 170. This is the beginning of the error table:

Error in ULPs

You may also consult the full table of lgamma error.

The conclusion is that FDLIBM’s implementation is the most precise, as it always has an error of at most 1 ULP.
Lanczos with 15 terms is good, as it has an error of at most 2 ULPs. Lanczos with 9 terms is somewhat worse, especially for small values. And Stirling is bad for arguments under 16, but above 16 has an error similar to Lanczos 15.

So FDLIBM’s lgamma() is the clear winner on precision. What about speed?
Below is the time (ms) needed for computing lgamma for all the integers from 0 to 170, 20000 times.

(smaller time is better)

The fastest method is Stirling (but unfortunately it’s not accurate for small arguments), followed by FDLIM’s lgamma(), which is almost twice as fast as Lanczos 15.
So the winner considering both performance and speed is FDLIBM. The downside of FDLIBM’s lgamma() is that it is a bit more complex that the other methods, and also it uses a table of 61 precomputed double values, which is 4 times bigger than the table used by Lanczos 15.

The full source code, containing the four implementations of lgamma(), the error evaluation and speed benchmark is available here:
Gamma.java

This is life without enums, macros or function pointers:

static final int
    SIN  = 1, COS  = 2, TAN  = 3,
    ASIN = 4, ACOS = 5, ATAN = 6,
    SINH = 7, COSH = 8, TANH = 9,
    ASINH = 10, ACOSH = 11, ATANH = 12,
    EXP   = 20, LOG  = 21, LOG10 = 22, LOG2  = 23,
    SQRT = 31, CBRT  = 32, POW   = 33,
    INT   = 40, FRAC = 41, ABS = 42,
    FLOOR = 43, CEIL = 44, SIGN = 45,
    MIN   = 46, MAX  = 47, GCD  = 48,
    COMB  = 49, PERM = 50, RND  = 51,
    FACT  = 52;

static final String names[] = {
    "sin",  "cos",  "tan",  "asin",  "acos",  "atan",
    "sinh", "cosh", "tanh", "asinh", "acosh", "atanh",
    "exp",  "log",  "ln",   "log10", "log2",  "pow",
    "sqrt", "cbrt",
    "\u221a", "\u221b",
    "int", "frac", "abs",
    "floor", "ceil", "sign",
    "min", "max", "gcd",
    "comb", "perm", "rnd",
};

/* keep 'codes' in sync with 'names' above */
static final int codes[] = {
    SIN,  COS,  TAN,  ASIN,  ACOS,  ATAN,
    SINH, COSH, TANH, ASINH, ACOSH, ATANH,
    EXP,  LOG,  LOG,  LOG10, LOG2,  POW,
    SQRT, CBRT,
    SQRT, CBRT,
    INT,  FRAC, ABS,
    FLOOR,CEIL, SIGN,
    MIN,  MAX,  GCD,
    COMB, PERM, RND,
};

double eval(int code, double params[]) {
    double x = params[0];
    switch (code) {
    case SIN:   return Math.sin(x);
    case COS:   return Math.cos(x);
    case TAN:   return Math.tan(x);

    case ASIN:  return Math.asin(x);
    case ACOS:  return Math.acos(x);
    case ATAN:  return Math.atan(x);

        //more follow
    }
}

The One laptop per child (OLPC) project aims to develop a $100 laptop, with the goal of enabling children education. The project is interesting not only because of the very ambitious price target, but also because it explores new directions in the hardware design of mobile devices:
- very power efficient: It has a 1.1 Watt CPU. The LCD screen has a new design allowing to use 1/7 of the typical power consumption of present LCD displays. Combined with smart power management (for example, the CPU may be suspended while the LCD is kept ON - allowing to use very little power when reading a book) this may allow the device to run for dozens of hours on a battery charge. This would be quite an advance from the laptop I use today, where the battery time is in the 3 to 5 hours range.
- transreflective LCD display. This allows good LCD visibility in sunlight, again something I’d want on my laptop.

I think it would be a good idea to offer a JavaME implementation (MIDP/CLDC) on the OLPC laptop. This will allow to use the large amount of existing MIDP applications (many of them games, but not only) on the laptop. Also JavaME is a simple (and easy to learn) programming environment that may be used to introduce the children to programming. Another point is that the existing MIDP applications are developed for devices with limited processor power and smaller displays, so they are fit for running on the OLPC.

It is good that Sun is already working on open-sourcing JavaME (this should be completed before the end of 2006, let’s hope), as this may allow easier porting of JavaME to OLPC.

As a consumer, I’d like to be able to buy one OLPC laptop for myself (and maybe one more for my wife), either in a physical store or over the internet, even though I’m not a child in a developing country anymore. I guess I shouldn’t need help from the governement of the country I’m in right now in order to be able to get a laptop (because it seems that the distribution channel envisioned by MIT right now is large commands from the Ministry of Education). Maybe one problem with offering such cheap devices on the market is that it will upset the vendors of mobile phones and laptops, which may oppose the project in order to protect their profits.

I’m about to buy a new phone.
I wanted a phone that can take acceptable pictures, so that I’ll be able to finally get rid of the digital camera (because I never have the camera with me when I need it). Acceptable pictures, I guess, means 2M or 3M resolution, with good image quality. Good image quality rules out the focus-free cameras (you need auto-focus to get acceptable quality). Also a flash for the camera would be handy of course.
I also wanted the phone to be able to play audio (music and audio-books). Radio would be good too.
In order to be able to store the pictures and audio tracks, storage space of at least 1GB is required. This can be built-in, but the most usual solution is for the phone to support removable memory cards. In the case of memory cards, I’m for the standard solution (mini-SD or micro-SD) and I’m against the proprietary formats that I can’t find in the stores (Sony memory stick).
I wanted to be able to run software applications on the phone, and to browse the internet, so a big screen with big resolution is good.
Concerning the connectivity, I want Bluetooth (because I want to experiment with it) and miniUSB (in order to be able to use a standard USB cable). Also I consider good battery life of paramount importance, because continously worring about re-charging the phone, and having to carry the charger with me everywhere is unconfortable.

These were my criteria:

- big screen, 240×320 resolution, 24bit or 18bit color.
- camera, at least 2Mpixel, with autofocus and flash.
- support 1G micro-SD or mini-SD removable flash card.
- bluetooth and mini-USB.
- good battery life.
- price: under 300 euro.

Implied: music player, JavaME MIDP-2.0/CLDC-1.1.

And guess what: I could find no such phone!

Candidates:
Nokia 6233, 6131, 5300:
The Nokia phones in this price range (under 300e) all have poor cameras; either 1.3Mpixel or 2Mpixel, no autofocus, no flash. I would rather have a phone with no camera at all rather then one with a useless camera. Arguably no-camera may reduce the price a bit, reduce the size/weight of the phone, and reduce the UI complexity, so it’s better to have no-camera rather then have a poor camera. Were I a manufacturer, I would offer two categories of devices: phones with good quality cameras, which can take the role of a stand-alone digital camera, and phones without camera.
Another minus is that the Nokia phones have rather poor battery-life.

Sony-Ericsson W800i, K810i, K800i:
the SE phones have good cameras, with auto-focus and flash. Also they have good music-players. But they’re too expensive (close to 400e), and they only offer the proprietary (Sony) and hard to find memory-stick as a memory card.

I also didn’t find any Samsung or Motorola model fulfilling the criteria.
I avoided Siemens (because they recently declared bankrupcy), and Sagem, Alcatel because they’re small brands and I don’t think they make good phones.

In conclusion, the fact that the device-convergence didn’t happen yet shouldn’t come as a surprise, as there are no convergent devices (at acceptable prices) yet. The mobile phone has the potential to take over huge parts of the digital-camera and music-player markets; this didn’t happen yet not because of consumer resistance, or some other socio-psiho-fashion factors, but simply because the phone manufacturers (hardware + software) aren’t doing their job well enough. The focus is too much on ‘gullible consumers’ who buy on impulse, guided exclusively by the look of the device, easily duped into thinking they can really take pictures with a 0.3Mpix VGA camera, etc. I would prefer less spending on advertising, and more investment into making better phones at accessible prices. And more care on the usability and software side, as too often good hardware is crippled by poor software.

Honorable mention: I really liked the little Samsung C130 at 45euro, even if it’s none of the power phone I described above.

It seems that Chinese phone manufacturer CKT is offering the 6689 phone with my menstrual cycle calendar application, Menstral, pre-installed. That’s great news, even though I wouldn’t have minded a line from CKT asking for permission.

Here are some links to pages talking about Menstral:

• Gizmodo
• ShinyShiny
• Stanford
• Mobsoft.ru

I developed this simple clasification of programming languages that is of no much use I guess. Perhaps it is inspired from the toothbrush clasification (hard, medium, soft):

1. Hard languages: C and C++
2. Medium languages: Java and C#
3. Soft languages: Perl, Python, Ruby
4. Exotic languages: Lisp, ML

The Hard languages are the oldest. They can reliably be used for any task, and are best suited for the largest programming projects. These are the languages in which are written Operating Systems and Database Servers. They use static typing. Many checks are done at compile-time (not at run-time). The advantages of C over C++ are lightweight-ness, portability, and easy bindings from any other language. The advantages of C++ over C are: classes (OOP), STL, Templates. For new projects one should generally choose C++, except for low-level libraries (like SQLite, Apache httpd, zlib, etc) which may benefit from C. On the down side, Hard languages are difficult to master and have the lowest productivity.

The Medium languages are very close to the Hard languages; maybe they can even be considered the ‘third-generation’ hard languages (C++ being the ’second-generation’ hard language). They also use static typing like the Hard languages, and they do many checks at compile-time. They can handle large programming projects. New relative to the Hard languages, they bring: Garbage Collection (GC) and Reflection. Java doesn’t have macros and Templates, and is controlled by Sun. C# is strongly linked to .Net and is controlled by Microsoft. They are more accessible then C++ (because it’s harder to make programming mistakes) and are a little bit more productive (mainly because of GC).

The Soft languages have dynamic typing, meaning that the type checks are done at run-time (not at compile-time). They are very productive. They are best suited for small-to-medium projects; their dificulty with large-projects stems mainly from the lack of compile-time checks. They allow new programming techniques and idioms that are impossible in the Hard languages (e.g. adding methods to a class or to an object at runtime, defining classes at runtime, etc). They are usually interpreted, and typically they have slower run-time performance than the Hard languages.

The Exotic languages offer interesting programming techniques. They are useful for developing one’s mental flexibility, and offer a deeper understanding of various programming concepts. So their role is mainly educative and explorative.

Let’s suppose that all the domain names start with “www.”, like “www.name.com”. This means that the leading “www.” doesn’t apport any information (because, as we supposed, every domain has it). You could just as well trasmit your name as “name.com”, knowing that the receiver will automatically add the necessary leading “www.”.

I mean that the leading “www.” doesn’t serve any purpose. It’s just a sort of historical garbage, and will be dispensed of. Your website name should be “name.com”. The domain “www.name.com” would redirect to the canonic domain, “name.com”.

This has the advantage that your name is shorter. A short name is friendlier for your users, because it’s they who have to type it, write it down, etc.

The dropping of the leading “www.” is already happening on the web; in a few year’s time, “www.” will be history. This gives us an easy way to spot the web dinosaurs, the domainers who are stuck in the past; a dinosaur is a domain which can only be accessed as “www.name.com”, while the shorter form “name.com” gives an error.

An example: www.whois.eu works, while whois.eu doesn’t work — Eurid, the operator of whois.eu (sorry, I meant to say www.whois.eu), is the paradoxical new dinosaur on the web.