Maxim Fridental

Preface

I don’t think of myself as a software developer.

My motivation to learn and work in software development was based on the idea of building things. But if you think about it, software alone is not a “thing”, it is just a component of software product. Even worse, it is an invisible component nobody really cares about, as soon as it is not overly buggy.

Software products interact with users thru their UI. The UI together with use-cases supported by the product and its marketing platform create a user experience, which IS the software product from the user’s point of view. Note how the software itself is not part of this formula

If software is poorly written, it makes it hard to evolve it in the future versions. Unfortunately, more often than not the responsible managers either don’t care or can’t tell clean and good software from dirty and poor one. So even this internal aspect of a “thing” — its evolvability — is often neglected.

Having understood that software per se neither a “thing” for the users nor a “thing” for product owners, I’m moving to positions allowing me to define what really matters — UI, Usability and the Product as a whole. But because I have much more experience as a programmer, I both still have and want to work on some down-to-earth, in-the-trenches software development. At least part-time.

Currently I’m discovering embedded programming in C and want to share my impressions.

Horror

I have used various high-level programming languages in the last 19 years, and the last 12 years were exclusively in high-level area. Of course I’ve used assembler and C for some of my first programs back then 20 years ago; I also had some course works at my university to write in C, and I’ve created a commercial firmware for a telecom device in 1999 using ASM.

But returning back to C after having obtained all the experience and knowledge of other languages is something different. C was the third or fourth programming language I’ve learned in my life (after BASIC, ASM and Pascal). I was 15 at that time. In this age, when you learn a new language, you just accept it as it is and only care about how to bend you mind around it to produce a compilable program. This time,  learned designs of quite different programming languages (such as Smalltalk, C#, Javascript, etc), I had the possibility to actually evaluate the C language design and the paradigms behind it.

And my first impression was horror.

C doesn’t have reasonable integer types
This one was perhaps the biggest negative surprise for me. I mean, C is currently used only to write some low-level platform and/or performance-critical stuff. Often, the exact bit size and alignment of your variables is very critical. And still, C’s built-in integer types are absolutely unusable. When you write int in C#, you have your 32 bits. Guaranteed, fixed, always the same for any platform from a tiny mobile phone to a powerful Azure server cluster, and this will never ever change. When you write int in C, you’ll get something, depending on your platform. The only thing you know for sure is that its bit size is greater or equal than char, and less or equal than long int. Well, thanks for nothing!

Because the integer types are so unusable, there are efforts to create appropriate pre-processor directives that will try to figure out the current platform’s native bit size and #define useful types. Unfortunately, there are several such efforts, and in the real-life down-to-earth C source code, you will see variables declared as int, int32_t and gint32, all meaning the same, and used in the very same function. This happens especially often when you have a software using several another components, which are open source.

C doesn’t have byte and bool
This is another WTF moment. C is often used in constrained memory conditions, so that you expect a very powerful bit and byte manipulation engine. But there is nothing.

Instead of byte, I saw char is being used (as well as uint8_t, guint8 and BYTE). Such a byte of course does not support bit manipulations out of the box (which is even worse than some assemblers!), so that you have to spend hours trying to figure out what values you have to & and | with some int to get its bits from 3rd to 18th.

As for bool, it is often #defined to be char or int. Sometimes, boolean types together with the false and true constants are #defined several times per module (one #define situated in some indirectly included header while another is directly in the file). But this definition of boolean is quite lousy one, because if and while are happy to accept any integer, so that compiler doesn’t have any static checking support. You can forget to dereference a pointer to your “bool” variable and the if would happily accept it as a true value; you will not get even a warning from the compiler!

Generally, C compile-time checks are lousy
To demonstrate the point, let’s look at this code:

int main (void)
{
  printf("This is a test!\n");
  return 0;
}

Just put it into the file test.c and then execute

gcc -o test test.c
./test

Now, as a naïve ex-C# developer, I would expect the first command fail with the error telling me that the function printf is undefined. Right, gcc would link with libc by default, but I’ve forgot to #include <stdio.h>.

Instead! Instead, gcc would tell you the following:

test.c:3:3: warning: incompatible implicit declaration of built-in
function ‘printf’ [enabled by default]

How on the earth is can be a warning, you think. Then you check your working directory and see the executable test there. And then you execute it with the second command, and what does it do? Crashes? No, it prints out the given string! Are you amazed?

It turns out that, in case C detects something looking like a function call, and the function is undeclared, it just assumes this function takes an int as its argument, and returns an int back.

No, I’m not kidding!

And no, I don’t know why it is an int->int and not float->void, for example. And why the hell this automagic is required at all…

But wait, okay, okay, whoa! We’re passing a string to printf, so at least after assumption its signature is int printf (int), the C should print an error and stop, for Lords sake? Well, you see, string is just char*, and this is a pointer, and a pointer… well, from where C is sitting, the pointer is just an int.

Sooo, let’s try it out:

int main (void)
{
  int ret = foobar(5);
  return 0;
}
 
int foobar (int a)
{
  return a + 1;
}

then

gcc -Wall -o test test.c
test.c: In function ‘main’:
test.c:3:3: warning: implicit declaration of function ‘foobar’
[-Wimplicit-function-declaration]
test.c:3:7: warning: unused variable ‘ret’ [-Wunused-variable]

So, in C, an arbitrary assumption that undeclared functions are int->int has the same severity level than detection of an unused variable. If not the –Wall option (almost the highest warning level of gcc), it wouldn’t even print any warnings at all!

Let’s now go wild and explore the situation a little further. The following source code could easily occur after / during a slight refactoring of function signatures:

#include <stdio.h>
 
int main (void)
{
  int i;
  int num_records;
  char* input;
 
  init();
  input = read_input_data(&num_records);
  for (i = 0; i < num_records; i++)
  {
    process_data(input, i);
  }
  return 0;
}
 
void init(int security_token)
{
  printf("Initializing with token %d\n", security_token);
}
 
int read_input_data(char* out_buf, int security_token)
{
  printf("Reading with token %d to buffer %d\n", security_token, out_buf);
  out_buf[0] = 'a';
  out_buf[1] = 'b';
  out_buf[2] = 'c';
  out_buf[3] = '\0';
  return 3;
}
 
void process_data(const char* buf, char* out_ptr, int num, int security_token)
{
  int i;
 
  printf("Processing from buffer %d to buffer %d %d items with token %d\n",
  buf, out_ptr, num, security_token);
 
  for(i = 0; i < num; i++)
  {
    *out_ptr++ = *buf++;
  }
}

When you compile it, gcc will print a lot of warnings but never an error, and produce the executable. When executed, it might print something like this before it crashes:

./test
Initializing with token 134513456
Reading with token 0 to buffer -1076015340
Processing from buffer 3 to buffer 0 11529179 items with token 12862244
Segmentation fault

So, apparently this implicit int->int function declaration is an overly simplistic description of how C handles unknown functions, which of course increases the number of wonderful cases where you have to fix a sudden segfault. I have no idea from where the values of missing parameters are coming, and what awesome security implications might happen when just commenting out some existing function and defining another one with additional parameter void*, which would allow you to write… where? On the stack?

Generally, it is hard to write a future-proof code in C
I like the following example:

#include <stdio.h>
 
typedef struct
{
  int  id;
  char* name;
  int age;
} Employee;
 
int main (void)
{
  Employee ceo = {0, "Bill Jobs", 55};
 
  printf("%s is %d\n", ceo.name, ceo.age);
  return 0;
}

It works as expected. Now, let’s say, we want to add department to the Employee struct. Piece of cake, right?

#include <stdio.h>
 
typedef struct
{
  int  id;
  char* name;
  char* department;
  int age;
} Employee;
 
int main (void)
{
  Employee ceo = {0, "Bill Jobs", 55};
 
  printf("%s is %d\n", ceo.name, ceo.age);
  printf("%s works in %s\n", ceo.name, ceo.department);
  return 0;
}

The same example implemented in C# would print “Bill Jobs works in”, because the department is not initialized and is null. On C, the second printf will segfault, because the department string is being initialized with the CEOs age. There is one step between a perfectly working software and a sudden segfault. Either that, or you have to extend any existing structs by adding new fields to the end.

These discoveries I’ve made in a mere several first weeks working with C. I’m looking forward to post even more similar war stories here. But horror was not the only feeling I had. Curiosity and a sudden recognition of how C is designed were a great fun for me.

Fun

Modularity concept

In the OOP world, we think in classes. It’s a habit. I was never concent with the silly tradition of C++ / C# / Java to store source code in files, because files add avoidable complexity. Best OOP languages like Smalltalk don’t need files and store the source code in a database. Therefore I was fascinated when I’ve first heard that Microsoft’s TFS was going to store source code in a database… Well, TFS turned out to be one of the most dissapointing Microsoft products to me, but that’s another story.

In C, they think in files, and they really use and need files. A file is a first-class concept in this language. Files are means of modularization. There are two kinds of them — the .c and the .h files.

In a .c file you normally put one or several functions. This is your module. Functions that belong together are stored in the same .c file. Some of them are exposed for usage from other modules (.c files), others are private (in C you use the keyword static to mark such functions).

Now, to call public functions of module A from another module B, you have three two options:

1) You can manually declare exported functions in the beginning of the module B.
2) You can manually declare them in a .h file and then #include it in the module B.
3) You can use implicit declaration for your int->int functions as described above.

This makes the .h files to be roughly an analog of interfaces or public class members in OOP. The difference is that you are not constrained by any formal rules. For example, you can combine exposed functions of several modules in one .h file, or have different .h files for the same module, or even do all that for the code you don’t own (and it might be already compiled). This is more flexible.

So, generally, when I write a new module, first I write a .h file to define its public interface, then I #include only those .h files into my .h file that are needed for my function declarations (mostly typedefs of missing built-in types). Then I write the .c file, #include the corresponding .h file to forward-declare public functions, then forward-declare the private functions, and then #include the .h files of all the other modules I need when implementing my module.

This is radically different from how I did that in C++ ten years ago, where I used to #include all possible header files to any other file, because I was pissed of by this manual file management and wanted to think in terms of classes and interfaces only, considering files as one (and the worst) of many possible source code storage backends.

Program for the compiler
When programming in modern languages, you have two very distinct modes: the run-time and the compile-time. My comeback to C has made me think about any program as being a double-program: the one for the compiler (executed at compile-time), and the other one for the run-time.

In the modern languages, the compile-time program is purely declarative without side effects. In C#, if you write

public class Point
{
  public int X;
  public int Y;
}

this is in essence a declarative instruction to the C# compiler to create a new class with the given members. It is declarative, because it doesn’t matter if this class appears in the source code before or after some other class; and the order of its members also doesn’t matter. The declarative compile-time style of modern languages makes it easy to think about it, so that you can distribute more of your focus to the run-time.

Not in C. There, the best way to think about a program is a double-helix DNA where procedural compile-time instructions are intertwined with procedural run-time instructions:

int open (void);
int write_data (int fd);
 
int main (void)
{
  int fd;
 
  fd = open();
  write_data(fd);
}

Reading this source code as compile-time program, first there is a command to put “open” and “write_data” with the corresponding signatures into the name table, then a command to put “main” into the name table, then a command to start writing compiled code of “main”, then the command to put “fd” to the local scoped name table, then a command to compile a function call to “open” and add it to the “main” function object code, and so on.

Thinking about it this way makes it easier to grasp the behavior of the language. Especially when you start using macros (and in C, you have to). And it explains quite naturally the need of forward function declarations and the importance of the struct member order.

In a sense it reminds me how Smalltalk (also an ancient language) works; there, new classes or methods are also defined by calling a procedural method. The difference is that in Smalltalk the syntax for the compile-time is almost the same as the run-time syntax so that you don’t have to learn two languages instead of one.

C with classes: GLib
C++ is often called “C with classes”, but this is not the only truth; the pure C has its own OOP implementation; in GLib they’ve managed to do it without modifying the programming language itself. And boy it is a funny hack, I must say.

Consider the following code:

typedef struct
{
  int  id;
  char* name;
} BaseObject;
 
typedef struct
{
  BaseObject parent;
  int age;
  int department_id;
} Employee;
 
Employee*  ceo;

They use the fact that according to the C standard, fields of the parent field are stored in the declaration order at the beginning of the Employee structure, so the memory representation of it looks like this:

struct Employee_in_memory
{
  int  id;
  char* name;
  int age;
  int department_id;
}

This allows you to cast pointer to Employee to pointer to BaseObject, because, hey, its fields are at the beginning of the memory. This enables polymorhism like this:

typedef struct
{
  BaseObject parent;
  int num_employees;
} Department;
 
#define MAX_REPOSITORY_OBJECT_COUNT 1000;
BaseObject* repository[MAX_REPOSITORY_OBJECT_COUNT];
 
int read_repository(void)
{
  int stream;
  int i = 0;
 
  stream = open();
  while(!is_eof(stream))
  {
    switch(get_next_type(stream))
    {
      case EMPLOYEE:
        Employee* emp = deserialize_employee(stream);
        repository[i] = emp;
        break;
      case DEPARTMENT:
        Department* dept = deserialize_department(stream);
        repository[i] = dept;
        break;
    }
    i++
  }
  return i;
}
 
void dump_repository(int top)
{
  int i;
 
  for(i = 0; i < top; i++)
  {
    printf("%d,%s\n", repository[i]->id, repository[i]->name);
  }
}

As for methods, you could just add function pointers to the structs, but this would mean you copy them with each object instance, which is a big waste of memory (at least according to the C ideology), besides, it would allow you to have different methods per instance of the same class, which is normal for languages such as JavaScript, but just too weird for the conservative C. Therefore, in GLib, in their very base object GObject they put a pointer to another structure, the class structure, which has the function pointers of the class methods. This has the added benefit of run-time reflection, because this class structure has a couple of fields allowing you to read the class name, query for properties and so on.

But, because of this, as soon as you have any non-trivial hierarchy with virtual methods and so, it would be too complex to use it directly in plain C (because of constant casting and using obj->parent and obj->class), so that GLib has added a lot of #defines hiding this complexity (but also preventing an easy understanding of what exactly is happening). Here is a good example of how a simple OOP code with GLib looks like. All in all it feels like programming in C++ with all its black box covers removed. But this is yet another story.

Before we start, I’d like to remind that this post, like all other posts on this site, reflect only my personal opinion, not of my employer.

There are more and more rumors that Apple will announce a new TV set around March next year, and the press speculates about its features and look.

Well, I think, TV sets have no future, and Apple will announce a TV set killer, not a better TV set.

Because, what is a TV set? It is a TV tuner plus a big screen. Modern devices have many additional features, including various inputs, network and Internet access, time shift, etc. But these features are all not defining. Remove time shift, and it is still a TV set. But remove the tuner, and it is just a monitor. But in broader sense, TV set is not only a device. It also defines how the television industry is structured. And it is also the way how viewers perceive role and place of television in their entertainment and informational workflows.

The life of a modern television user is hard. To operate the TV, he has (or expected to) understand

• the differences between analog and digital TV
• the differences between DVB-T, DVB-S and DVB-C
• the difference between free TV and pay TV, and understand the need of set-top boxes and CI slots and cards, and has to be a guru to understand what kind of set-top boxes is compatible with what kind of pay TV stations
• what do SCART, HDMI, VGA, DVI, S-Video, etc. mean and what adapters are needed or possible
• the difference between PAL, SECAM and NTSC
• How teletext, EPG and Hbb-TV are different from each other, and how to use all of them (differently for each TV station)
• CD, DVD, DVD+-RW, Blu-Ray, USB sticks, SD and CF cards: when to use them, and how to play their contents on TV
• Files: Xvid, DivX, WMV, AVI, MP4, MPG, MOV, MKS, RT, TS, VOD, M2TS… and how to play them on TV
• What is a media center, and why there are different media center concepts: a set-top box implementing media center functions? A Blu-Ray player with integrated media center? Media center in a hard drive? Or in the Internet router? Or in a NAS storage? Or inside a low-noise PC besides the TV set? And if using PC, what software to use: Windows Media Center, xbmc, … Or better an XBOX besides the TV extending the media center on PC?
• What is a game console, and what is the difference between XBOX, PS3, Wii…

I guess, there are a lot of paid jobs out there, requiring to know and to understand less than the TV industry currently demands from their customers to know and understand, just to be able to entertain themselves.

People are not like this. They don’t like knowing and understanding things. They just want to be informed and entertained, and the device in their living room should “just work”. No matter if they want to play a networked first-person shooter game, to check the current Dow-Jones index, to enjoy some movie, or to observe a football match — the device must work consistently and straightforwardly.

Apple’s success in other industries suggests that contemporary people are ready and willing not only to pay a huge premium to somebody who would allow them not knowing technical details, but also give up a bit of their privacy and freedom for that. This gives the possibility for Apple to enter to this market — the market’s consumers are ready for the change (they just yet don’t know it).

And they are ready for the change, because the current situation is so unsatisfying (from the usability perspective). The reason for that is the TV industry structure, consisting of stations, networks, and CE manufacturers. Heritage of governmental control times, this structure is the primary reason of the current deadlock and absence of innovations (3D video leading to headache and requiring to put on glasses, like children playing in doctors? come on! This is exactly what the most viewers were missing so far!)

Just think about it. CE manufacturers create screens attracting eyeballs of huge population for unbelievable several hours a day, every day. Social network startups capable to attract a tiny fraction of this love are being sold for billions of dollars. Yet the manufacturers neither able nor know how to monetize it. As a result they have to live on near zero margins. No wonder they cannot innovate; money is just not there.

And even those who have money, wouldn’t design their devices to be perfectly usable by the end user; instead, they design it to be conforming to various industry standards, and to be appealing to the sellers. Typically, earnings of TV set manufacturers depend not on viewer satisfaction, but rather on sellers satisfaction. It doesn’t matter how well the device can be used, it is only matter how well it can be sold. So, the usability of devices is just “nice to have”, and this is the reason of the famous “blinking 00:00 VCR display” issue: you have to bend your mind around to understand how to set the clock.

Network companies have had a terrible, huge, unbelievable high investment in the infrastructure and cannot allow any innovations not compatible with it, until the investment pays off. Their earnings do depend on user satisfaction, but they have educated the viewers that television HAS to consist from three components (the device, the cable and the stations), so that they are and feel themselves only responsible for their part and would therefore happily sleep another 100 years monetizing their DVB infrastructure.

Stations have potential, knowledge, understanding and talents to improve television and make it more immersive and more user friendly. Alas, they get all the advertisement money, so that their motivation is rather altruistic and artistic rather then dictated by the hard rule of the market. Besides, they don’t have the possibility to change technology used in the infrastructure and in devices. And developing their own devices and using another infrastructure (for example, Internet) doesn’t seem to be their core competency. The best they have produced (in Europe) in this area was the Hbb-TV.

Apple has the possibility to unlock it. The secret of success for their mobile devices was that they simultaneously:

• Own the usability and user experience of the device, both in hard– and in software
• Own the entertainment content distribution
• Partially control the network by partnering with mobile operators and providing their server backend for iTunes
• Partially control the marketing, by selling their hardware directly to the customers, on-line and in Apple stores, and selling the software via tightly controlled App Store.

These factors were responsible for providing entertainment intensity of levels of magnitude higher than those of Apple’s competition.

Apple also has experience unlocking such convoluted markets. The mobile market in the pre-Apple era has had similar issues: mobile operators invested in the infrastructure and wanted to sleep forever monetizing it, and device manufacturers didn’t sell directly to the customers, but had to satisfy the sellers (mobile operators and electronics chains) and couldn’t monetize the usage of their devices. As the history teaches us, people have readily paid up to 10x times more for something more usable, more immersive and more entertaining.

So, how this TV set killer device could look like? I don’t know. It depends heavily on talents Apple has, on result of negotiations with other industry players they might have conducted, on commercial feasibility of some specific technologies, etc, I have no idea about all that. If I was in charge and didn’t have any limitations, I would do the following:

1) Create a technology for games similar to XNA allowing to write games for iPhone, iPad, Mac and the new device, all using the same toolchain. And convince some key players in the game industry to port their successful franchises to this platform.

2) Ensure a live streaming cloud capable of taking broadcast signals and streaming them via the Internet in near real-time with high quality, no interruptions and integrated time shift and VoD. And convince some key TV stations to license their programmes (this is where Google TV has failed).

3) Partner with somebody helping me to convince others, for example with a best ISV in the country.

4) Create a device, which would have a big bright screen with the best video processing (400 Hz, motion compensation, scaling, etc), terrific multi-core processor with several TFLOPS, but still without any noisy rotating parts (I’m looking at you, XBOX), a modified iOS, huge and quiet HDD or SSD, best available Wi-Fi, perhaps some web cameras, but nothing else: no other connectors (except of power), and may be one power button.

5) Ensure all kinds of content can be streamed to the device via WiFi using the Internet protocol: VoD movies, music, and apps from the Apple store servers, live broadcast from the new cloud service, and user-own content from his Apple devices in his local network, or from his iCloud. As well as converting locally available signal sources (cable, satellite, VCR, PC) for those who still need them, using an optionally available adapter box.

6) Create a content-centered UX concept. Viewers wouldn’t switch between signal inputs (channels, connectors, sources) as they do now; they would choose between contents. Do I want to rent this movie, or watch that live sport event, or look at my own photos shot by iPhone and uploaded to the iCloud, or would I rather play this game? This is the kind of choice viewers will take. And for lean-back scenarios, a partner TV station network will provide some live channel that will be “tuned on” by default.

As for the actual interaction technology, I do believe Apple will invest much in it, be it just a remote control, Kinect-like NUI, Siri-like voice control, or something else. But in my opinion, this wouldn’t be a big variable in the equation. The mere absence of all this stuff users have to know to operate TV would be already a huge difference. The Apple’s device will “just work”, i.e. just inform and entertain.

If Apple will really do that, and this will really work, all the traditional industry players will have hard times competing. One realistic option would be to jump into the Google TV bandwagon, a similar strategy many mobile players went with the Android. Another one is to go with Microsoft, who have recently announced some interesting and revolutionary changes in the XBOX (which I to my confusion didn’t yet have had time to check out) and clearly aiming at the same market. And the last option: to give up the TV set market, and try to earn money on something else.

So, before I close this very long post and having predicted the close future, I’d also like to predict the distant future. After unlocking the TV market, where Apple will going to look next? My bet is that it will be cars and homes. Both industries are stagnating, both have a pretty awful usability (operating 3 pedals and several levers just to drive from A to B with high risks for the life? Ridiculous! Having to endure bad neighbours, just because it is so hard to move a house? Stone age!). So get ready for your iCars and iHomes.

And after solving that, we can then slowly approach what really matters: the human beings, with their bodies and their psyche…

NB. I’m sorry for typography of this post. “3D” and “PS3” look really awful. Unfortunately, I’m limited here by the standard WordPress editor and don’t know how to improve it.

What motivates people to create open source software? On the one hand, efforts required for it are greater than those couple of days spent by students on solving their toy assignments, on the other hand it is almost impossible to sell, and it is very hard to do “consulting” kind of business around it. So why is it worth efforts?

Keeping in mind those 7% of strange altruistic people, the resting 93% of OSS developers are apparently developing it because of the following reasons:

• They are being paid for it by companies, who want to compete with closed source companies
• They want to find a (better) job, so they need both skills and publicity
• They want to be popular.

Web 2.0 and mobile apps have seriously disturbed the latter two motivations.

Several years ago, if you wanted to be a cool hacker, you created some OSS software worthy to be included in GNU or Apache repositories. Today, if you want to be a cool startuper, you just create a web service or a mobile app.

Open sourcing web services is useless, because their source is often trivial, and whenever it is not, it cannot be reused, except of creating an exact clone. And web service clones are not interesting, because the original service would usually soak up all possible user base, and without users, Web 2.0 apps are pathetic.

In this respect, uselessness of web services source code is quite similar to the source code of Adobe Flash Player or Microsoft Silverlight. Because it doesn’t matter what you can do with these sources, what matters is which version is installed on the most PCs out there.

With the mobile apps it is even more interesting. Apple’s license agreement is explicitly not compatible with GPL, and Free Software Foundation is understandable scolding them for that. Besides, source code of most mobile apps should be quite trivial, because the most of their added value lies in their interaction design / UX; and in the connected web services.

So, if you want to get better job or get popular, you can just create a web service (and a couple of mobile apps for it). And as a nice side-effect of NOT open-sourcing them, you can even earn some money (from the App Store or by selling the app/service to somebody big).

So what is the future of Open Source? Are we evidencing its peak today? Can it be saved? And… do we want to save it?

The infamous internal-accidentally-turned-external post of Steve Yegge (now deleted, but saved for history in many places, for example here) is a typical rant. You know, that kind of rants where you start writing about one big topic, then jump to another unrelated one, and then bounce in-between trying to come-up with a resume reasonably combining them into something that ought to appear a neutrally-tempered educational article rather than an outburst of your accumulated emotions.

I like rants. I like passionate people, and I like watching them showing their world. And, as a rule of thumb, rants usually deliver a valuable insight or unexpected point of view.

This time, it was the Product or Platform story. Summing it up in a nice bite-sized paragraph, it goes like this.

Great products must hit the nerve of your users. Product managers are bad at predicting where exactly the nerve is, before their product hits the market. Thus, they often have to adjust the product (sometime drastically) in its further iterations. Therefore, you should develop not a product in the first place, but a platform for making products. This will allow for quick after-TTM product adjustments; and for external contribution into killer product features.

Just like with many right ideas, it is not new per se, new is only that is it written down so explicitly.

Take Axinom for example. Instead of creating yet another version of their CMS, they did a revolutionary thing: they have created a specialized UX platform — a collection of patterns, concepts, and technology allowing them quickly produce highly ergonomical and immersive information management applications. Having that, they have now all the means to implement really killing apps for their customers. And they’ve invented it way before the Mr. Yegge’s rant.

With the SilverHD DRM product, we went along the similar path. Based on our know-how about all kinds of typical business models used by different VoD shops in the European market, we’ve created concepts and technology allowing to securely define entitlements (who is allowed to consume which media under what restrictions). The concrete DRM mechanism to enforce these entitlements was purposedly left variable; we’ve started with PlayReady and WM-DRM; and it will perhaps be adjusted in the future with other DRMs such as Widewine or Marlin.

Switching jobs is always stressful. But changing from web development with Microsoft technologies to embedded Linux development is like bungee jumping. Not that I’ve ever jumped bungee. But I like overstated comparisons

Seriously, judge for yourself.

Before, I was proud that I’ve ever compiled Linux kernel from its sources before (which is untypical for a hardcore Microsoft fan). Today, I re-complile the kernel several times a week.

Before, I was proud that I know what DirectShow filters and the graph are (which is untypical for a normal Silverlight developer). Today, I fix bugs and develop own filters for GStreamer, the open-source alternative of DirectShow.

Before, I thought http and TLS are parts of operating systems. Today, I’m fighting with gnutls trying to cross-compile it properly.

Before, I thought 100 Mb of source code is “a lot”. Today, I’m working on 6 Gb of sources.

Before, I’ve heard about TS files, which were mysterious creatures coming out from content providers and had to be transcoded ASAP into a more usual format. Today, TS is my common denominator, and I juggle with all these PATs, PMTs, SCTs, PCRs, PIDs and PTSes (per stream).

Before, I’ve thought 1Gb of video file is a full-length movie, and 8Mbps is a lot of a bitrate, and 720p is HD Video. Today, 1Gb is a short 5-minute Full HD clip.

Before, I feared of JavaScript, because you inevitable have to deal with HTML when working on JavaScript. Today, I fear of JavaScript, because when I cross-compile source code of WebKit with too much optimizations, its JavaScriptCore engine will expose all kinds of weird errors.

Before, I was ironical about how low-level the .NET 1.1 and .NET 2.0 were in comparison with Smalltalk. Eventually Microsoft has promoted C# to be a reasonably-high level programming language in .NET 4.0. Today I work in an environment where they think C++ is a high-level language, but is overly complicated, while the pure C is just the right level.

Before, I thought Windows 7 is on the verge of getting old. Today, my colleagues think Windows XP is not yet outdated.

So, in some aspects, this is a pretty much “upside down” experience, but I hope I will find my place in this new world, just like I’ve found myself in the web development seven years ago.

There are quite a lot white papers about security on software level. You know, all those situations when an attacker sends some information not in the format expected by the software, and the latter fails; or passing some pieces of code in the registration form in places not intended for that and ending up with executing this code, or similar issues.

There are much less works describing security of some existing and popular Web 2.0 services (Facebook, Flickr, Google+, Picasa, Xing, LinkedIn, etc). But at least there are some.

What seems to be absolutely absent are white papers describing security (and more specifically, privacy issues) of the Web 2.0 ecosystem as a whole. Meanwhile, the situation there is quite remarkable. Fans of conspiracy theories would immediately assume that intelligence services of many countries are currently holding their breath observing rapid and voluntary de-privatization of many netizens; gathering all the information and preventing hackers from publishing their findings. Well, if it should be true, you are currently NOT reading this text, because it wasn’t successfully published. A more rational explanation would be, that just lazy me didn’t do any research before writing this blog post and has instead just bluntly asserted that there are no white papers on this topic to made his blog post more appealing.

Anyways.

To depict the current status quo, I’m going to show a couple of legal techniques to gather private information about a person from public sources.

1. Profile Scouting. This is obtaining links to public profiles of a target person, in a given Web 2.0 service:
                a) By known real name. Many Web 2.0 services allow (and even motivate) their visitors to search profiles by known real name. This step can be either performed manually for each Web 2.0 service using the corresponding search field, or automatically using pipl.com.
                b) By known username. Some Web 2.0 services display the username publicly, either in the web page itself, or at least as part of the public profile url. So, either public profile url can be constructed manually and checked if a given Web 2.0 service would return a profile or a 404 page, or some automated service can be used for this task, for example namechk.
                c) By known place of living, company, school or interests. Many Web 2.0 services allow to search using these kind of metadata; from the resulting list of persons the target person has to be found using some additional information, for example their known appearance (looking at the profile photo). A variation of this method is using groups or forums; for example, if a target person is interested in some dance type, and some Web 2.0 service offers a group, it is possible to find them by looking up the members of the group.
                d) By tagging. For example, a group photo on Facebook might be tagged with corresponding profiles; knowing appearance of the person of interest, it is possible to obtain their public profile. Another variation of this method is tagging of Flickr photos, where tags containing person names, cities and event names are used.

2. Profile Mapping. Having a profile in one Web 2.0 service, it is often easily possible to find out profiles of the same person in another Web 2.0 services; for example, by searching the same known real name. Many folks out there use the same username (or same couple of usernames) across several Web 2.0 services, so that their profiles can be mapped that way. The easiest way to map a profile is just a link, for example, it is possible to enter a link to Flickr account in the Facebook profile, and make it visible for everyone.

3. Social Graph Leveraging. This means, analyzing the “friends” of a target profile. This technique has the following shapes:
                a) Leveraging Faulty Security Concept. For example, the target person has closed their photos on Facebook for public viewing, but opened them for their friends. A friend of the target person has a publicly available timeline and comments on a photo of the target person. Faulty Facebook allows anybody to follow to this comment and to see the original photo, even though it ought to be visible only “for friends”. I believe, this bug Facebook has at least since I’ve joined it in 2009.
                b) Leveraging Different Privacy Settings. Let’s say the target person has closed their photos for public, but their friends haven’t. Some friend would publish their own photo, showing themselves, but also the target person (perhaps in the background or showing their back, but not necessarily so). Another variation of this technique is consuming the publicly available timeline of a friend of the target person, if it is known they interact closely in the real life (for example, study in the same university). By observing events, life style and mood of the target person’s friend, it is possible to conclude that the target person themselves should also have comparable mood, life style and perhaps participate in the same events.
                c) Second Level Scouting. Let’s say, the target person A doesn’t want to publicly befriend another person B (due to any reason whatsoever). But, A’s friends C, D and E don’t have this constraint and all have B in their friends. By analysing common friends of the friends, it is possible to find a missing link. This technique has quite limited usefulness, as your typical Facebook profile has 100 to 200 of friends, the total number of friends of friends can be around 10000 in the worst case, which is way too much to be analyzed manually, and I don’t know any ready-to-use software that would automate such a “friends scouting”.

Combining these three techniques sequentially, it is possible to achieve impressive results. For example, it should be possible to start looking up the target person A by searching their real name and current city on Flickr. By a lucky chance, one could find only a couple of photos, and most of them would depict the target person. One then could go to the Flickr profile of these photos’ author, person R, and map their profile to Facebook. On Facebook, by a lucky chance, one would be able not only read the public timeline and obtain more photos, but also discover a couple of friends of R who would live in the same city, for example persons H and D. By mapping of H’s profile to spaces.live.com it could be possible to obtain additional photos, and by mapping D’s profile on a Web 2.0 service for travel reports, one could obtain additional information about some events happened.

I do believe these techniques are quite legal, because they leverage only the data made publicly available by respective owners / copyright holders. If this should be “problematic”, then Google and other spiders should be even more questioned and investigated.

On the other hand, depending on exact situation and on what exactly the researcher will do with the information found, this might be anything from being perfectly moral to being absolutely cruel. In any case, often it is the case that information flow is not as intended by the target person, and that’s why I think this issue is a security issue, and has to be publicly discussed and addressed.

I don’t know any handy solution for that, besides of trying and opening my own social profiles to the most possible extent. If I cannot prevent this kind of information gathering, at least I want to lead and control it by providing the most of information myself “from the first hands” and thus minimizing any possible misunderstanding or misinterpretations. But I do see that this approach is not suitable for every kind of situation.

So what do you think about it? I’m kindly requesting for your comments.

Software architecture is art of expressing business with technology.

Technology has its limitations. If you pursue business goals without getting in touch with the technology, you will hit its limitations. When business hits technology, the latter won’t be hurt. The former will.

Business has not unlimited time and budget. If you evolve technology without getting in touch with the business, you will hit its limitations. When technology hits business, the latter won’t be hurt. The former will.

Great software architecture is when business dances with technology, and nobody gets hurt.

Rule of thumb: if software architect isn’t in touch with business, the software architecture will be worthless (at best), or dangerous for the business.

Rule of thumb: if software architect isn’t in touch with the source code, the software architecture will be ignored (at best), or dangerous for the technology.

Rule of thumb: software architecture written upon a requirements document (only) is invalid. Software architecture written without (at least) prototyping it in source code (better: implementing first iteration of production code) is invalid.

While the first reactions to Windows 8 UI demo ranged from “whatever” to “WTF”, most of them were focused on the published technological decisions rather than UX aspects. I want to present my opinion about the UX itself.

The very first word coming to my mind when I see the Metro start screen is “gaudy”. And no, it is not Gaudi, it is gaudy like that. 

There are too many details on the picture preventing it from having a clearly defined focus. This problem is not so visible on the WP7 devices, because of their small size and different usage pattern (more about it in a minute), but it is also present there.

Comparing Metro with the Start button and the taskbar of the previous Windows versions and with the taskbar of MacOS X, I believe this is a step back to the state even worse than Windows 3.1. Novices and elderly users will be confused, now knowing where it is safe to start.

Comparing Metro with the iPad, the latter has a very ordered matrix of relatively small icons with huge free space in between, while Metro glues all apps in a chaotic unfocused block of something.

In the real life, the start screen will look even worse than this carefully crafted one shown above, because random apps can (and therefore will) have mutually incompatible colors and visual styles. Again, having small icons with large free spaces like in iPad or Windows 7 alleviates this problem; having huge color-filled tiles glued together accentuates it.

Speaking of real life, the cut titles of the panorama control might look cute when the wording is carefully chosen and titles are hardcoded, but can quickly become a distracting factor when using a real-life, random user-generated data. And I don’t even want to start speaking about languages with words much longer or much shorter than English, or about the RTL languages.

But wait, things will get even worse with the announced dynamic updates of the tiles. As far as I understand, each app will be given the freedom to have its own notification UX. Just imagine these all apps glued together, blinking, rotating, jumping and putting on contrast colors to get users attention! Does it feel like a field of nasty banners to you?

For a minute, why would I want an app to display a notification at all? I tell you, even the uniform small decent red circles used in iPad are every time a disaster for my mother. The AppStore app just wants to tell her there are some updates. Actually she uses only two apps and shouldn’t care about updates at all. But because this notification looks so “urgent red”, she feels to be forced to update, just to get rid of this visual distractor. Which is a huge pain on iPad, because neither the AppStore app nor my mother can remember the password.

On Windows 8, such users would feel themselves even on greater pressure to “satisfy” all the apps, just to stop them blinking and jumping. Which is, in my opinion, not the way the user interaction has to be on slates and desktops, as opposed to mobile phones.

The mobile phones user interaction is very specific. A mobile phone IS in fact your personal notification device, with the added service of not only notifying you that somebody wants to talk, but also allowing you to actually talk with him. Half of the reason to always carry mobile phones with you is the ability to be notified, either instantly, or next time you look at the device.

Tablets are different. It you carry them with you at all, it is because you can — they are small and light enought to provide their services even on the go. But the services themselves have nothing to do with the location and mobility. Tablets are entertainment and working devices.

When I turn on the tablet display, I’m not going to quickly check what is going on while I’m trying to walk and hold an umbrella at the same time. No, when I turn on my tablet, it means I have some spare time I want to waste use to consume information: catch up all Twitter and Facebook updates, read some of the web pages linked from these posts, and maybe continue reading those Kindle books. I don’t really care that the apps have something for me to read. I don’t really care I even have apps. All I care for is that I have something to read, hear or watch.

If I was forced to use the Metro UI language even despite of its inherent gaudy nature, I’d shown content items in the tiles of the start page, instead of the apps, and I’d built the UX concept around elimitating tiles from the space by reading them. You turn on the tablet, you read the first tile containing a twitter message, you tap on it, it disappears. You continue consuming content items, possibly skipping some of them, until you have removed all the tiles except of the long-running ones (like Kindle books or movies). This would eliminate the nasty question of “where do I want to go first” and provide a simple and stable information consume workflow. Perhaps I’d allowed users to sort and filter the tiles. Or may be not even that.

On a positive side, I’ve spotted a photo selection interface, where the content items (the photos) are represented as tiles, and by tapping you can put any number of them for further processing in the footer area. This has vividly reminded me an UX idea we have implemented at Axinom back in 2008 for a Silverlight VoD shop

I’m looking forward to the next Windows8 videos from the Microsoft UX team.

User Experience of a software product is an extremely integral and cross-discripline thing. They are many ways to ruin it — unusable content, wrong emotional tonality of graphics, unrealistic usage scenarios, suboptimal interaction design, technical compromises, you name it… Perhaps, security is the only other quality of software, which ubiquity is on par with UX Design. Hey, hacker scene has quite a lot in common with UX scene — isn’t that a coincidence? But I digress.

A cult UX design needs a single person who is both extremely talented in such different things as artistic and technical implementations; and has the absolute power over the software product.

In all other cases, a UX design process may help to achieve passable results. Now, as you know I’m not exactly fan of processes. A formal process is often just a way to solve personal problems — and I don’t believe personal problems should be solved in this way. So, even though I’m speaking about a process in this article, I’m not going to have others (or even myself for that matter) to follow it, but rather see it as a means to create a common coordinate system and terms.

The ultimate quality of software product is defined by how it sells (for commercial software) or how popular it is (for Web 2.0). For the purpose of this article, we factor marketing activities out of the equation, assuming that they can only put additional focus on product’s qualities, not replace them.

One quality factor are the hard facts. “Rendering a web page with IE9 takes x milliseconds, which is yy% quicker than any other browser”. Another factor influencing product quality is user experience, which is, how the user feels about the product.

For some products and markets, hard facts and UX would make 50/50, for some others 80/20 or 20/80.  In any case, UX remains one of the main factors helping or preventing a software product to achieve its goals.

Watch with me a typical lifespan of software product UX design.

The software product starts with a rough idea, a small but powerful grain. In the conceiving phase, this idea is gradually defined with more and more detail, until it spawns leaves of “modules”, a rough architecture of the product. Let’s make a snapshot of this state and call it a vision document.

While it remains on the business level, the definition process continues, so that separate features starts to appear inside of modules. At this point of time, the most important decisions about who are our users and what are their main scenarios are already taken. The most important features even start to appear quite material. Take a picture again, and call it high level concept document.

But what it is? An unusual process begins to happen with features. They start to move and boil and jump between modules and change themselves quite a lot. Some features would die, just to see other features appear on their place. As a result, from the chaos of the proto-features, a clearly ordered and beautiful structure appears. At the same time, features gradually materialize so much that their wireframes become visible. Now, by looking at how stable the wireframes are attached to the overall structure, you can get an impression that this UX could be implementable. Push the button and save it as detailed concept document.

A stream of pure creative energy hits on the wireframes to remain in form of emotions expressed as graphics, sound, movement… Don’t miss the moment, make tons of pictures and call them comps.

The product is beautiful now, but it is still sleeping. Invisible for the eyes, life is being created inside of it. Sooner or later it will wake up, and gratify the product team with its first cry…

To make this fairy tale happen, several professionals (or better to say, roles) work on UX:

• Creatives: Artists, graphic designers, animation designers, sound FX designers, typography designers, industrial designers… Their main goal is to pick up users emotionally. The reason Apple fanboys are so forgiving about Apple products is that the products are so emotionally compelling. You don’t complain that the place of the “close” button is unpredictable from app to app, because this button is so crisply and carefully rendered, and because the screen where it is placed is so well balanced visually.
• Interaction designers, usability experts, information architects — people who care about the mental model users will get when using the software. Who are our users? What are their goals? In what scenarios are they going to use our software to achieve their goals? How can our software be helpful in these scenarios? How to remain flexible and support plenty of user scenarios, but not to overwhelm users with too many choices?  While the Creatives target the right hemisphere of user’s brain, IX designers appeal to and care for his rational side.
• Developers. Not every UI concept can be implemented within reasonable time and money. Often, UI concepts have to be developed on verge of implementability (I remember the guys from Windows Media Center team were astonished when we’ve showed off our image coverflow implemented in MCML — something you’d need to bent your mind around for a couple of days, given existing technical limitations). Also, if we want product quality to remain high in the mid-term, software architecture must reflect the UX design.
• Business. Obtain or ensure compelling content. Ensure enough time, money, people, and hardware. Present UX design to stakeholders while controlling their desire to influence it. Otherwise, stay out of the way of the product team. Business as usual.
• Testers. They can be the first to smoke test the UX design decisions, before they will roll out to private beta. Their goal is to provide an outsider point of view.

How exactly these roles are mapped to real people, and where roles start and end, is often matter of discussions. Besides, the process doesn’t account for agility and iterations, as well as for parallel development that has sometimes to be done to hit a deadline, and, and, and…

But this is a topic for another story.

As Apple has presented iPad 2 recently, it is time for me to sum up my iPad user experience. Because Apple focuses on the overall user experience, right? And the competition focuses on specs and features, and this is wrong?

At least this is how Techcrunch has understood the Jobs’ message. Unfortunately, I cannot confirm it with an original video from Apple.com, because this site requires me to install Quicktime browser plugin to watch videos, without giving any other possibility. And I’m not going to install it, because unlike Flash and Silverlight I know that a) Quicktime is only needed for this one single site in the Internet — the Apple.com, and b) I had a nightmare experience with some previous version of the Quicktime player for Windows before — this bloatware had installed ton of services eating up my memory and CPU cycles and had constantly tried to upsell me into the Pro version. So: no, thanks.

But I digress. So, the iPad 1, and its overall user experience. I didn’t buy it for myself, it was a gift for my mother. Everybody needs a computer nowadays, but she in her 60’ies is not very computer affine, even though she is a computer technician by her education. So I thought, an iPad doesn’t have a file system, nor device drivers, nor firewall & antivirus software, and iPad is from Apple that is being rumored to be a company that cares for user experience. So I thought, iPad is the best fit for my mother.

She is a normal retired person that wants to follow her children on Facebook and Flickr, get connected with her former classmates and friends, read books, occasionally write a couple of invoices, and otherwise read mail and try to surf in the Internet.

So I have bought the 16Gb iPad without 3G, from a local German shop.

The first very positive experience was that it came with the fully charged battery so that I could start using it right away. This is really cool and this is how all gadgets should be delivered.

And the first very negative experience happened soon thereafter. I’ve switched the UI language to Russian, because well, my mother is a Russian living in Germany.

Have you ever seen the German iPad switched to Russian language? Apple, have YOU ever seen it?

Let me read for you the application names the iPad has displayed: Safari, Mail, iPod, Youtube, App Store, Настройки. Yes, these names appear exactly like that in the UI, with only the last app (which is Settings) being translated. Now, don’t get me wrong: my mother is a great well educated women, but she speaks only Russian and German, and have learned French in the school. That is, no English. How is she supposed to understand what “Mail” is? How is she supposed to understand that Safari has something to do with the Web, and not with hunting in Africa? She has never used an iPod and so also has no idea what THAT could be. And Youtube she cannot even read properly.

And I remind you, it is the iPad bought in the German shop, switched into Russian UI language. What the hell all these English names think they are doing on its screen?

Let me spare detailed description of how exactly bad the localization of Apple software into Russian is. I will only provide you with one, the final example. The Pages app, also by Apple. Do you know how they translated the “Undo” button into Russian? “Не применять”, which means, “Must not use”. I’ve avoided to tap on this button, because I (me! a software developer!) was unsure about what exactly will happen if I would use it. Luckly, by chance I have seen a screenshot of the English version of Pages…

So, the first shock of the localization disaster calmed down, and I started to pre-configure the iPad with some useful stuff before I will present it to my mother. For example, I wanted to buy some content for her.

The first try: iTunes. I’ve searched for some movies in Russian (produced in Russia). Zero. Then I’ve searched for some movies produced in Russia, but translated into German. Zero. Then I’ve searched for popular German movies. I’ve found one or two, which wouldn’t interest my mother. The rest were Hollywood movies translated into German, with quite expensive prices for the German VoD market (think maxdome.de, download.mediamarkt.de, videoload.de). Not very appealing.

Then I’ve switched to music. I’ve searched for some Russian performers. Nothing. Then for some well-known German ones. Nothing. Then for some Chinese performers (I happen to like Chinese music). Nothing. What they have is basically the USA music charts. Not very appealing.

So I went to Safari and navigated to some Russian VoD shops, where you can buy a Russian movie and watch it online. What have I forgot? Yes, you’ve guessed it right. No Flash support in iPad! And those shops are all using Flash.

So.…

Then I’ve tried the iBook app. Should I describe what happened? Yep, you’ve guessed it. No Russian content at all, not even Russian classics translated into German. Not even any interesting German book! Only English content. But wait. I can download a book as PDF and then read it with iBook, can’t I?

Yes, I can. I just need to connect the iPad to iTunes on my PC or Mac and use it to place the book into iBook app. I cannot “just” download the book in Safari on the iPad itself and read it in the iBook. Hm. But wasn’t the whole idea of the iPad in my case to be a replacement for a full PC or Mac? So why do I need an additional computer in my household? OK, I have by chance a “real” computer at home, but I don’t have iTunes, nor I need this bloatware on my Windows PC. Is that what Apple understands when they speak about overal user experience?..

But I digress again. Failed to provide tons of useful content, I’ve turned over to installing useful apps. I wanted to provide a cool option for her to follow me on Twitter, Facebook and Flickr. The only free Facebook app I’ve found is designed for iPhone. There were too many Flickr apps, but most of them were paid apps… And twitter client I’ve found some, but it wasn’t integrated with Facebook. I’ve spent perhaps an hour trying out several apps, and the best fit I could find was the Flipboard. Unfortunately, this app has also an English UI only, so that my mother isn’t using it often (or at all?). And, unfortunately, this app has only English language news sources (just like the Pulse app has), and doesn’t allow to add a custom RSS (for example this blog’s RSS). Well, again, here may be I’ve just missed a cool and useful app — if you can advice me with an app showing RSS, twitter, Facebook and Flickr and also allowing to post to your own Twitter and use all the features of Facebook, and that with UI translated to Russian or German, please let me know. But, actually, shouldn’t Apple have had prepackaged such an app with the iPad? After all, they have pre-packaged the web browser and the mail, something that Microsoft was not allowed to do in Europe…

So Ok, after some time and having prepaired the iPad as good as I could, I’ve presented it to my mother. She was clearly excited about its look and feel, and she could start sweeping and tapping on it almost instantly. I’ve ensured her that she cannot break its software, and that allowed her to overcome her usual fear for PCs. She has found Youtube and we could watch a couple of free (or should I say pirated?) and short Russian clips on Youtube. So the first day went quite OK, besides of the last thing my mother wanted to do with the iPad. She wanted to “say bye”. Let me explain that. Her first computer was a mainframe in the office she worked at. This mainframe had an IBM operating system with a command line interface. To begin to use it, you were supposed to type in “hello” and then your user name. To log out, you had to type in “bye”. The mainframe operators were intructed very stricktly that they HAVE to “bye” to finish the work session with the computer. So what my mother was missing is the similar way for the iPad.

I must say that this is the feeling I’ve also had sometimes, for example with the Pages app. When you’ve finished writing a document, your “natural” wish is to “save” or “freeze” it somehow. But there is no button with “Save” on it that would give you that warm safety feeling.

Speaking of the Pages app, the thing I missed was a documentation (a user guide). I’ve spent may be 5 or 10 minutes trying to understand how to insert a new row above an existing row in a table, but no combination of tapping, sweeping, dragging and pinching could do the trick. After all these tries I’ve felt myself being an ape trying to open a coke can but now knowing how. So I was very impressed to see that my mother was able to use this app to type a whole one-page invoice, with all the formatting and details she needed. Apparently, she was not disturbed by absence of any clues of how to use the formatting features. Perhaps because she didn’t use any.

A similar experience I’ve had with some other apps, for example the iBook or Mail. When you compare iBook, Mail, Pages and Numbers, you will see that these apps sometimes don’t keep similar interactions in the similar ways. For example, the close button might be in the top left, top right, or bottom right corner. Or a button with a box and an arrow going out of this box could mean quite different things, like answering a mail, forwarding a post, or sending a document to printing. Again, my mother seemed to be not disturbed by such inconsistencies.

One of the use-cases for iPad that additionally appeared was using of Skype. So I went to a local shop with the idea of buying a web cam and a headset that can be attached to the iPad port, or an adapter for that. Nothing found. Do I understand correctly, that video conferencing is not supported? And why it isn’t? Does the iPad have a slow CPU and / or no GPU? Do we want to speak about features and specs, and the price I had to pay for the device now?

After all, I’ve spent $640 on it. That’s right, the device that costs $499 in the USA will cost 499€ in Europe. If I was buying a desktop PC for that price, I would be able to use Skype, read books without any additional software, use Microsoft Office (and have a usable physical keyboard for that matter), etc. Unfortunately, I would also have files, drivers, firewalls and other unneeded stuff…

So, my resume of this long post: all in all, it wasn’t a mispurchase. My mother has fun and manages to use the device, at least those apps that are adequately translated or don’t need any translation. But, it was quite an expensive fun, and it was a user experience quality level that I absolutely cannot match with all that hype Apple fanboys and fangirls are producing in the press.

As soon as anybody would produce a reasonable OS for a normal PC hardware, without all this file, driver, firewall stuff etc, I mean an OS suitable for seniors, there are chances I will immediately try it, and, who knows, the next computer my mother will get will not be an iSomething.