![[info]](http://l-stat.livejournal.com/img/userinfo.gif){kind=small}
sibereansibereansibereansibereansibereanStatus of This Memo
This document proposes a method to use public Internet as a global infinite
storage for personal information and a way to group and separate a public
personal information from other information.
Copyright Notice
Copyright (C) The Internet Society (2005).
This document and translations of it may be copied and
furnished to others, and derivative works that comment on or
otherwise explain it or assist in its implmentation may be
prepared, copied, published and distributed, in whole or in
part, without restriction of any kind, provided that the above
copyright notice and this paragraph are included on all such
copies and derivative works. However, this document itself may
not be modified in any way, such as by removing the copyright
notice or references to the Internet Society or other Internet
organizations, except as needed for the purpose of developing
Internet standards in which case the procedures for copyrights
defined in the Internet Standards process must be followed, or
as required to translate it into languages other than English.
The limited permissions granted above are perpetual and will
not be revoked by the Internet Society or its successors or
assigns.
This document and the information contained herein is provided
on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET
ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE
OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY
IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A
PARTICULAR PURPOSE."
Grouping and storing personal information in Internet as in a global 'Cloud'
V.Gavrilov June 2009
The Internet today (so called WEB2) is more and more used for decentralized
storing and editing of articles, comments, blogs, bulletins, wikis which are
hosted on different public sites. But there
is no a standard way of extracting all the information published by a user,
grouping and searching of such information, an easy way of separating
ones personalized information from the miriads of published articles by
other users.
This grouping exists only in editor's head as personal associations
and memory. With time passed by - some publishings are lost, URLs and
domains may change and boookmarks are expiring, so the only way to find
one's published information is to search the Internet again and ... try
to find one's information by hand - from millions of results returned by a
search engine, narrowing requests and searches.
Proposed here is a simple method of grouping personal information by attaching
of a signature to every published message where the signature is a short
result from a one-way hash-function generated from a combination of a user's
name, date of birth and a personalized message - to avoid collisions.
To avoid confusion with the term "digital signature" from asymmetric
cryptography - let's from now on name our signature/hash as NID (Network ID).
A scenario could look like the following: while browsers still not supporting
NID - a user could temporarily copy/paste NID during every personal post.
In the future - user will be able to query a favourite search engine for a NID and will get
only his personal stuff - been separated from the rest of Internet information
because NID forms a word generated from a personal unique information which
will highly unlikely occur somewhere else.
In future - browsers or search engine could support a checkbox: "Personal/Public"
and selecting of this checkbox - will allow to extract only the personal
information from the Internet, the user ever published (using this NID).
This is a simplest scenario. More complex usages of different groupings of
personal information (forming multiple groups inside one personalized group by
means of attached to the NID keywords) - may be easily shown.
Let's consider a simple implementation of such NID generator.
It is obvious that the compactness of NID is highly desired. And it seems
that for such purpose - even 128-bit MD5 algorithm can be used successfully.
(Actually, the published vulnerabilities of MD5 on collisions will not have
impact on this particular usage due to the predefined and short string, from
which the key is generated and secondly - even if a collision will occur - it will
not have a big impact, so will not be such critical). From another side -
22-char string hash result (base64 encoded 128-bit binary output from MD5) is
short enough - to be stored extensively in the Internet in every post or article.
Generating of a personalized NID may be hypotetically demonstrated by the following
UNIX command * (it will be actually longer that 22-char since the standard built-in
md5 uses less compact than base64 encoding: HEX):
% echo "Vasili Gavrilov 01011968 my cat's name - Kuzma" | md5
% XQgYnkgYSBwZXJzZXZlcm
where "my cat's name - Kuzma" is a seed/salt, added for avoiding collisions
of multiple persons having the same name and were born on the same date and also -
to avoid generating of the NID by another person - to extract somebody else's
information (if the name, DOB and protocol of NID generating are known).
What should be noted here is that there should be at least minimal protocol of
what fields are to be used and in which sequence - for generating NID - to avoid
collisions by using of too simple feeds into md5+base64 combination.
This RFC is intended for begining of discussing of this convention.
For example - the protocol could require to write first name, last name,
Date of Birth and "salt" - in this order (in any case, with any delimiter or
vice versa - with predefined delimiter and casing - TBD. Benefits of that?).
An extension of the protocol could be an attaching of a personal keyword or
an association - to the NID.
For example, when storing something connected with photo - the user could attach
"photo" at the end of the NID:
XQgYnkgYSBwZXJzZXZlcmphoto
and in future - searching the Internet for this string will give a user all
the entries ever stored with this key.
Storing of multiple keys NIDs with multiple keywords will allow to create
arbitrary groups and search engines will do their regular job for intersecting
of the groups.
What should be noted here is that it will be hard for another person - to get
somebody else's information due to irreversibility of the hash function and
existence of the 'salt' acting as a 'password'.
No one is restricted to use more than one NID, so this is very different
from assigning of NID to every user forever and so - this seems to be very
privacy-friendly approach also.
In future - browsers (or search engines) may support transparent appending of NID
to the requests and searching for the past personal postings connected with "photo" and
"vacation" will be able to achieve by just entry in a browser:
"photo vacation" - as it is done currently against common data.
Since above-mentioned checkbox "Personal" will be checked-in - a browser will attach
locally saved (or saved in a Cookie or a session) NID and will send a more restricted
request returning only the user personal postings (from multiple sites) containing
both keywords "photo" and "vacation".
We could imagine other extensions such as attaching of a counter or
another id at the end - to allow saving of redundant (the same) data into
multiple sites and for easier distinguishing of the duplicated data in the browser.
This can be further elaborated.
The above-mentioned procedure allows to use public internet as an infinite storage
of personal data and easy extraction and grouping of such data and separating
of public data and data saved by a person. This also transforms saving of the data
into the Internet into saving into one global 'Cloud' and abstracts the location
(URL may change but the information will still remain searchable).
This will allow the personal data to be distributed equally on multiple public
storages and in future - possibly to organize personal distributed services, working
with personal data in really parallel way.
sibereansibereansibereansiberean
$ g++ -O2 -o map map.cpp
$ ./map
records loaded in 0.233988
records red in 0.67486
$ gcc -O2 -o mapc map.c
$ ./mapc
records loaded in 0.177162
records red in 0.183764
$ head dict
a
A
AA
AAA
Aachen
aardvark
Aaren
Aarhus
Aarika
Aaron
$ cat dict | wc
62074 62074 547509
$ uname -a
Linux compaq 2.6.18-6-amd64 #1 SMP Tue Aug 19 04:30:56 UTC 2008 x86_64 GNU/Linux
$cat map.cpp
#include <map>
#include <string>
#include <iostream>
#include <fstream>
#include <sys/time.h>
using namespace std;
int main() {
map<string, string> hash;
string line;
struct timeval start, middle, end;
time_t s,ms;
gettimeofday(&start, NULL);
ifstream in("dict");
while (in >> line) {
hash[line]=line;
}
gettimeofday(&middle, NULL);
s = middle.tv_sec - start.tv_sec;
ms = middle.tv_usec - start.tv_usec;
if(ms<0){ s--; ms+=1000000; }
cout << "records loaded in " << s << "." << ms << "\n";
for(int i=0; i<10000; i++) {
hash["abracadabra"];
hash["vasya"];
hash["test"];
}
gettimeofday(&end, NULL);
s = end.tv_sec - middle.tv_sec;
ms = end.tv_usec - middle.tv_usec;
if(ms<0){ s--; ms+=1000000; }
cout << "records red in " << s << "." << ms << "\n";
return 0;
}
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/time.h>
#define MAX_MAPPING_FILE_LINE 1024
#define MAX_KEY 1024
#define OUT_OF_MEM() { \
fprintf(stderr, "Out of memory: %s:%d", __FILE__, __LINE__); \
exit(-1); \
}
typedef struct hash_bucket{
char* key;
void* data;
struct hash_bucket* next;
} hash_bucket;
struct hash{
long size;
long n;
long used;
hash_bucket** table;
char name[256];
};
static unsigned long calc_hash(char* str){
unsigned long hash = 0;
int c;
while ((c = *str++))
hash = c + (hash << 6) + (hash << 16) - hash;
return hash;
}
struct hash* hash_create(long size){
struct hash* table;
hash_bucket** bucket;
long i;
table = (struct hash*)malloc(sizeof(struct hash));
if(table == NULL){
OUT_OF_MEM();
}
if (size <= 0){
free(table);
return NULL;
}
table->size = size;
table->table = (hash_bucket**)malloc(sizeof(hash_bucket*) * size);
if(table->table == NULL)
OUT_OF_MEM();
bucket = table->table;
if (bucket == NULL) {
free(table);
return NULL;
}
for (i = 0; i < size; i++)
bucket[i] = NULL;
table->n = 0;
table->used = 0;
return table;
}
void* hash_put(struct hash* table, char* key, void* data){
unsigned long val = calc_hash(key) % table->size;
hash_bucket* bucket;
if ((table->table)[val] == NULL) {
bucket = (hash_bucket*)malloc(sizeof(hash_bucket));
if (bucket == NULL)
OUT_OF_MEM();
bucket->key = strdup(key);
bucket->next = NULL;
bucket->data = data;
(table->table)[val] = bucket;
table->n++;
table->used++;
return bucket->data;
}
for (bucket = (table->table)[val]; bucket != NULL; bucket = bucket->next)
if (strcmp(key, bucket->key) == 0) {
void* old_data = bucket->data;
bucket->data = data;
return old_data;
}
bucket = (hash_bucket*) malloc(sizeof(hash_bucket));
if (bucket == NULL)
OUT_OF_MEM();
bucket->key = strdup(key);
bucket->data = data;
bucket->next = (table->table)[val];
(table->table)[val] = bucket;
table->n++;
return data;
}
void* hash_get(struct hash* table, char* key){
unsigned long val = calc_hash(key) % table->size;
hash_bucket* bucket;
/* printf("getting attempt %s<\n", key); */
if ((table->table)[val] == NULL)
return NULL;
for (bucket = (table->table)[val]; bucket != NULL; bucket = bucket->next)
if (strcmp(key, bucket->key) == 0)
return bucket->data;
return NULL;
}
static int read_mapping(const char *filepath, struct hash *map){
FILE *fp = NULL;
char line[MAX_MAPPING_FILE_LINE];
char *delim;
char *valStart;
long lineNum = 0;
long len;
char key_buffer[MAX_KEY + 1];
char val_buffer[MAX_MAPPING_FILE_LINE + 1];
if ((fp = fopen(filepath, "r")) == NULL){
printf("Cannot read %s\n", filepath);
return -1;
}
errno=0;
while(fgets(line, sizeof(line), fp) != NULL){
if(errno){
fprintf(stderr, "Can't read from file %s: %s\n", filepath, strerror(errno));
exit(-1);
}
if(line[sizeof(line)-1] == '\n')
line[sizeof(line)-1] = '\0';
len = strlen(line);
if(len == 0){
fprintf(stdout, "WARN: line %ld is empty -- ignored" ,lineNum);
continue;
}
strcpy(key_buffer, line);
strcpy(val_buffer, line);
hash_put(map, strdup(key_buffer), strdup(val_buffer));
}/* fgets */
errno=0;
fclose(fp);
if(errno)
fprintf(stderr, "Can't close file descriptor %s: %s\n", filepath, strerror(errno));
return 0;
}
int main(void){
struct hash* map;
struct timeval start;
struct timeval middle;
struct timeval end;
time_t s,ms;
int i;
gettimeofday(&start, NULL);
map=hash_create(100000);
read_mapping("./dict", map);
gettimeofday(&middle, NULL);
s = middle.tv_sec - start.tv_sec;
ms = middle.tv_usec - start.tv_usec;
if(ms<0){ s--; ms+=1000000; }
printf("records loaded in %d.%d\n", s, ms);
for(i=0; i<10000; i++) {
hash_get(map, "abracadabra");
hash_get(map, "vasya");
hash_get(map, "test");
}
gettimeofday(&end, NULL);
s = end.tv_sec - start.tv_sec;
ms = end.tv_usec - start.tv_usec;
if(ms<0){ s--; ms+=1000000; }
printf("records red in %d.%d\n", s, ms);
return 0;
}
Berkley algorithm used in custom hash (the most suitable for human language hashing): I've got 0 collisions populating English words (dict) using it and 70 colisions - with Bernstein algorithm, so I'm using the Berkley one)
static unsigned long calc_hash(char* str){
unsigned long hash = 0;
int c;
while ((c = *str ))
hash = c (hash << 6) (hash << 16) - hash;
return hash;
}
import java.io.*;
import java.util.*;
public class Map{
public static void main(String[] args){
try{
long t0 = System.currentTimeMillis();
HashMap<String, String> hash = new HashMap<String, String>();
BufferedReader is = new BufferedReader(new FileReader("./dict"));
String line = is.readLine();
while(line!=null){
hash.put(line, line);
line = is.readLine();
}
System.out.println("records loaded in " + (System.currentTimeMillis()-t0) + "ms");
t0 = System.currentTimeMillis();
for(int i=0; i<10000; i++) {
hash.get("abracadabra");
hash.get("vasya");
hash.get("test");
}
System.out.println("records red in " + (System.currentTimeMillis()-t0) + "ms");
}
catch(Exception e){
e.printStackTrace();
}
}
}
#include <map>
#include <string>
#include <iostream>
#include <fstream>
#include <ext/hash_map>
#include <sys/time.h>
//std::string does not have declared the following because
//hash_map is considered to be ext, so declare it here:
namespace __gnu_cxx
{
template<> struct hash< std::string >
{
size_t operator()( const std::string& x ) const
{
return hash< const char* >()( x.c_str() );
}
};
}
using namespace std;
using namespace __gnu_cxx;
int main() {
hash_map<string, string> hash;
string line;
struct timeval start, middle, end;
time_t s,ms;
gettimeofday(&start, NULL);
ifstream in("dict");
while (in >> line) {
hash[line]=line;
}
gettimeofday(&middle, NULL);
s = middle.tv_sec - start.tv_sec;
ms = middle.tv_usec - start.tv_usec;
if(ms<0){ s--; ms+=1000000; }
cout << "records loaded in " << s << "." << ms << "\n";
for(int i=0; i<10000; i++) {
hash["abracadabra"];
hash["vasya"];
hash["test"];
}
gettimeofday(&end, NULL);
s = end.tv_sec - middle.tv_sec;
ms = end.tv_usec - middle.tv_usec;
if(ms<0){ s--; ms+=1000000; }
cout << "records red in " << s << "." << ms << "\n";
return 0;
}
sibereanAs it is well known – big IT clients (such as banking, government, utility companies, insurance companies, big retailers) are very hard to shift and reform. The reasons behind this inertia include: 1) there are many regulations and rules, so it is hard to push forth innovations, as opposed to smaller IT organizations; 2) those are ‘Gig’ clients and they frequently employ 3rd-parties for their IT needs (consultants, subcontractor firms, IT 'solution providers'), frequently not having industry-leading experts in-house; 3) the existence of inherited infrastructures closely bound with 'solution providers', means that the companies the ‘Gigs’ are dependent on, are not constantly bombarded by big competition (due to already-existing implementations and infrastructure). It is thereby likely that the next project will be implemented using existing infrastructure technologies in an iterative manner, rather than adopting something from the outside. This is because, at first sight, the cost of addition (of another feature or a new project) seems to be low (since infrastructure is already in existence), and similarly, the risk seems to be low – at least from the managerial perspective ('works – do not touch!').
But there are catches: the overall license costs are astronomic; they are periodic, permanent, and on the increase. The more projects bound with the technology, the harder it will be to cure/reform the system in the future (more projects will be necessary to promote change). It is a unidirectional move toward an infinitely growing budget, where dependency on the vendor (vendor-lock) increases as more and more projects are added. Another big issue is the fact that some 'Gigs' include not-for-profit organizations or the government. So, there is a clash between the interests of for-profit vendors interested only in the growing presence of permanent cash-flow from big organizations like governments, and the interests of governments to re-allocate limited resources to other urgent needs such as health-care or education (discussion of this is beyond the scope of this article).
However, there is another, more significant closed loop (for closed loops – read about the recursive functions theory or see Hofstadter’s book*): the people’s skills loop, which is much harder to break. Nobody who has been recently considered a highly-paid professional will want to start as a university graduate, putting passed courses diplomas and certifications aside to start learning something completely different (in which universities are frequently giving more deep education) and to collect experience in those new areas, from scratch.
It is much easier (as it seems to many) to find another place where their old skills are still required, or more likely, to change absolutely nothing but rather push the manager to pay for another license term.
So the loop consists of the following:
1) The industry requires some skills to support the infrastructure that is already in existence (because there are always old projects on the basis of old technologies, somebody needs to maintain them);
2) Education centers (it is a free market!) provide the courses which are acquired by “Gigs”, where only 'Gigs' can be the main customers of such courses (universities are cheaper!). Then sub-contractors and consulting firms looking into the demands acquire professionals with the same skills;
3) Professionals push the solutions that they know, that they were taught and have had experience with (not those which are the most cost-efficient and/or which they do not know);
4) Managers (of ‘Gigs’ IT departments) look into _current_ industrial trends (who defines the trends?) and courses-on-offer (particularly, those they are most familiar with, having completed the same certifications). They then send personnel into the same fields (that again, they, the managers, are most familiar with).
5) IT personnel, having completed their certifications at the courses, implement the same closed solutions, thereby continuing the closed loop.
It is a primary feature of closed loops that they cannot be resolved by themselves (Gödel theorem) and hence a solution can come only from the outside.
But there comes a crisis (outside forces) which cures the system!
Let me explain:
In this article I'd like to highlight the interesting correlation between crises and significant innovations in big static IT departments: periods of crisis and innovation alternate.
By crises I encapsulate both recent decades’ oil and commodity price drops and financial crises. It will also be discussed how the IT industry was able to break vendor-locks in the past and find more (cost) efficient schemes of computing, i.e. to cure itself. Solutions come from outside of those closed-loops, and the ill industry (bound with some old vendor-lock solution) accepts those innovations, thereby reforming itself.
We will not touch on home computing (Amiga, Atari, Mac, PC and mobiles burst of the recent years) – since in this article the focus is on the ‘Gig’ IT industry. Although workstation costs, especially licensing, may be very significant for big organizations, the assumption is that workstation or client machines are a part of the whole infrastructure and are usually closely bound with the technologies used on the central (server) machines. We are more interested in server machines, OLTP machines, central batch processing units, database servers – machines serving big numbers of clients (clients may be both external, such as public Internet users, or internal, such as Intranet workstations users). Those central machines are usually the most expensive ones (mainframes or server farms, clusters, multi-way servers, big file and database storages) due to expensive top-hardware as well as high license costs (usually per-processor).
Although commercial computers appeared in the 50s – let’s begin in 1975 since before that there was a pure mainframe era, where one vendor dominated the market.
Let word financial crises (drops of oil prices) be marked by pipes on the year lineage below. As can be seen, periods between both crises and significant shifts toward less expensive technological innovations, span an average of 7 years (2000 is an exception: y2k bug fix is there which is a very special case – for the industry).
--75----------80----------85----------90-
| | | | | |
The single-digit numbers in the next chart represent eras or computing epochs (will be explained later), where the edges between epochs (pipes) can be characterized by significant shifts in technology/thinking towards more competition. Notice again that in this article we are interested only in ‘Big’ computing and ‘Big’ computers while by the shifts we mean innovations, ‘revolutions’ in the minds which brought some kind of decentralization in each case, introducing a less costly architectural solution for the problem.
It is interesting how those ‘significant shifts’ occur exactly in the middle of crises regardless of the cause: whether a cheaper solution is a consequence of the corresponding crises because of industrial demand (demand in a cheaper system), or vice-versa: each crisis simply releases more talented professional resources into the world, and those talents (the number of which is always limited) have more time for free creativity: to make a better system. And then the system (‘Gigs’: banks, government IT etc) just inevitably accepts those ‘solutions’, born outside as the more efficient.
Notice that a totally new system/solution cannot be created 'inside the system', it must be 'above' the system, coming from the outside (which has a deep mathematical background, beyond the scope of this paper).
--75----------80----------85----------90-
1| 2 | 3 | 4 | 5 | 6 ?
1) Mainframe era
* all systems are proprietary, expensive, centralized
* one vendor in the market
* only the wealthiest organizations can afford such systems because of the cost: millions of dollars
2) Minicomputers era (3rd generation computers like DEC PDP-11/50):
* first TSS (time-sharing systems) appear
* no payment for central computer time
This is a paradigm shift from #1, and there is no longer a dependency on one vendor: it is a move to decentralization.
3) Era of commercial Unixes:
* much more 'standard' and simple system than #2
This is a revolutionary shift because compared with the old custom systems, where no standards existed, - more vendors can implement well known, and which is more significant,– simpler OS design standard.
* there is competition between vendors (HP Unix, IBM AIX, Sun Solaris), and moving to less expenses boxes
* standardization of DBMS: SQL standards. Oracle, supporting the standard begins dominating (as opposed to hierarchical or other databases)
* networks boost encourages more decentralization. Databases can now be installed on different Unix systems and competition is rampant.
4) Windows (personal home computer) arrives into enterprise as an even cheaper solution than #3 (less than tens of thousands of dollars per server rather than hundreds of thousands of dollars per Unix servers):
* PC hardware is seen as ‘almost free’ hardware. Although there are catches (which are ignored as solvable by themselves within a few years): in particular, robustness and scalability. The main point: the software in this period is still far from being free.
* But the programming becomes cheaper and cheaper (C++, VB,
* More recent invention of the Web (actually it was earlier, in 91, in 3, but only now it becomes practically useful due to faster cheap networks), – everything is moved into the web: both thick and thin clients (the latest are reincarnations of ‘dumb’ terminals from 1, 2, but now – running on $1k commodity hardware). Windows dominates the client and also NT comes into the server.
* Cheaper MS SQL server competes with Oracle.
5) Java becomes the main application logic language, pushing out C++ and Y2K contributes to java dominance as the language of business logic (Cobol substitute in many projects).
* Appearance of the first good free environments (for java for example).
* Open-source arrival into enterprise.
* Google proves that even clusters hardware may be commodity cheap hardware running free software.
6) After Dot-Com crash.
* Linux becomes scalable enough for the enterprise (after the appearance of the 2.6 Linux kernel) and starts to substitute commercial Unixes inherited from 3. Now the whole OS on the server can be free.
* Commodity processors (Amd64) becomes 64-bit. Now free 64-bit OS can be installed on very cheap 64-bit processors. For example - clusters (and most of the Top500 computers) are built exclusively using commodity processors (such as AMD64).
* Free databases become scalable for enterprise (MySql, PosgreSql)
* Open-Source arrival to the enterprise
* Web2 (O’Reilly terminology): building of rich applications on the web. Competition in browsers area, standardization of JavaScript, DOM and CSS which avoids necessity in non-web rich clients
* Outsourcing of the software development and hosting (although this is not always appropriate)
So, this epoch can be mainly characterized as the arrival of free high-quality and scalability for enterprise software (most of epoch 5 software was non-free). This process is still continuing and more and more big companies and governments are moving towards open-source software running on free OS, development under free IDEs, the use of free frameworks and complete free sites (example Drupal and hundreds of PHP, java frameworks).
Now, in 2008, we have reached the next crisis. How we can make IT more cost-efficient now? What remains expensive in IT infrastructures today? Where do vendor-locks continue to exist?
RDBMS used in big installations are still mostly vendor-locked and non-free. Free databases (such as MySql and PostgreSql) are successfully used by small companies for very large installations, scaling well for a very large number of clients, but still rarely used in government environments (although more and more installations have already proven their efficiency). As it is seen by many people – there will be a big shift in this area (I put a question mark in the chart – estimating the point when the period will end). I believe (sure, if the progress will go on and no reason to think otherwise) that probably all the databases will already be shifted to free ones by 2012 and most DBAs will be familiar with them - in the same way that all epoch-3 (thick client) programmers became familiar with the web. So, licensing costs on the server-side is still a big issue for big organizations.
Application servers and development environments are frequently non-free (due to the existence of EJB architectures) but this is quickly changing, moving to the lighter ORM solutions (such as hibernate) or direct JDBC database connections (interfacing through SQL in a PHP manner) where there are no over-engineered additional client-server layers with all the added and unnecessary caching/scalability complexities.
The simplification of server infrastructures (removal of complex custom extra tier and scaling by means of database clustering and fail-over) and the making of the Open Source database as the standard can be compared with the arrival of Unixes during the Minicomputers 2 era (as the new simpler standard).
What else is still vendor-locked? The client (mostly XP), inherited from era 4 (license costs multiplied by number of machines), while Ubuntu or Debian (or any other) Linux distribution with OpenOffice and thousands of free tools can cover 90% of user tasks on the client desktop. Sometimes even a light-client remote office will work (similar to what Google is trying to promote), but either as a client through the old familiar X or a web-client to a Google-docs-like but – installed on the Intranet server – for familiar secure document editing. Old robust NFS, maybe together with SMB, all familiar Unix tools, but now – free.
Making big infrastructures vendor-lock free, regarding the software – is the only way – to break another closed loop and to make IT departments eat less money from organizations during hard times.
And we have shown that the whole computing history is the permanent move to less and less vendor-locked systems to cheaper and lighter (simpler) solutions. There is no reason for this process to stop. Crises are just catalysts of this process and bring more clever and simpler solutions from outside of the systems. Even such restricted-to-change organizations as government IT's have to accept those changes for their own survival and benefit. The above-mentioned possible moves (databases, desktop client) toward free solutions are only guesses, but analogies with past era movements make me think that those assumptions are right - also, this is the only right way to go (the obvious, progressive way): to the less vendor-locked world.
Nov 23, 2008
*) Douglas R. Hofstadter “Godel, Escher, Bach: An Eternal Golden Braid”, 1979, 1999.
siberean
 | You are viewing siberean's journal Log in Create a LiveJournal Account Learn more |
