The anti-rating of people causing the most technological damage

This is the rating of the worst engineer decisions causing the most damage to the civilization.

The 1 st place. Brian W. Kernighan and Dennis M. Ritchie.

Estimated amount of damage: $50 trillion.

What they did: They invented C programming language.

The damage: Due to a sticky tradition most operating systems are written in this silly programming language, what leads to countless errors, hard work of programmers, and long compilation time.

What they should have done: They should have use Pascal. (Pascal that time missed dynamic memory allocation and modules, but that would be easy to add.) Or alternatively they could do C with proper module manager rather that silly #include directives and support named constants.

The 2nd place. Bill Gates.

Estimated amount of damage: $30 trillion.

What he did: He stole the idea of Windows from Apple and made the worst operating systems series in the history. Due to good marketing and also due to a short time gain of a certain version of his system using less memory than Unix, his bad product became a de-facto standard, pushing down better competitors.

Damage: Bad system, bad programs for it, countless lost files, countless holes used by viruses and other malware. This jerk lost more than he “earned”: even his own computer cannot have good software. Yes, because of his stupidity this jerk has bad software on his personal PC.

Windows has the following disadvantages:

– high cost;

– low quality:

– low speed;

– high load on the computer, high power consumption;

– unreliability;

– poor protection against viruses and other harmful programs;

– bad tools for programmers, and as a result, low quality and high price of programs, reducing the number of different programs;

– poor customizability of the system, often the lack of alternatives;

– opportunities for Western forces to spy on you, because the system is closed and its analysis (counter-espionage) is complicated, and also because of the need to adopt a supplier’s privacy policy;

– complex and inconvenient installation and software update;

– slave binding to Windows as a drug, it is difficult to use alternative systems;

– problems with updating the system, rare and conceived paid updates;

– the impossibility of transferring the system from one computer to another;

– poor support of some modern technologies.

By the way the following program prints 666:

sum=0
for c in "BILLGATES": sum+=ord(c)
print(sum+3)

Why +3? He is Bill Gates III.

Curse him when your PC hangs. Curse him for all other computer problems.

What he should do now (to improve his living level): Abandon Windows and advertise Linux.

The 3rd place. Donald Knuth.

Estimated amount of damage: $5 trillion.

What he did: He invented TeX, the system used now to typeset most scientific articles and books, such as college textbooks. The system has thoroughly bad syntax.

Damage: Scientists spend time in making TeX work instead of the research. As of 2019 it is impossible to publish scientific articles to the Web. Scientists can’t even put ads on their articles to earn a little money this way.

What he should have do: invest a few hours of his time into designing a proper syntax for TeX.

Donald Knuth is the author of a good book, Concrete Programming, however.

Advertisements
Posted in Uncategorized | Tagged , | Leave a comment

XML Boiler (Automatic transformation of XML namespaces) is released

I am happy to announce the first release (v0.1.0) of XML Boiler (Automatic transformation of XML namespaces) software.

This release is alpha. But it seems to be already useful. For example, the documentation of XML Boiler is built using XML Boiler itself.

Here is the list of advantages of this new kind of XML software:

 

  • freely intermix tag sets of different sets of tag semantics (using XML namespaces), without disturbing each other (such as by name clash) in the global world
  • add your new tags to HTML (and other XML-based formats)
    • get rid of using HTML in future Web, switch it to proper semantic XML formats
      • make XSL-format based browsers with automatic generation of XSL from other XML formats
    • make automatic coloring of source listings (for example)
  • add macroses and include (such as by XInclude) other files in XML
  • intermix different XML formats, with intelligent automatic processing of the mix
    • embed one XML format in another one
    • automatically choose the order of different XML converters applied to your mixed XML file
  • make browsers to show your XML in arbitrary format
  • make processing XML intelligent (with your custom scripts)
  • integrating together XML conversion and validation scripts written in multiple programming languages
  • associating semantics (such as relations with other namespaces and validation rules) to a namespace
    • semantics can be described as an RDF resource at a namespace URL (or a related URL)
  • TODO
  • many more opportunities
  • integrate all of the above in single command

 

Posted in Programming, XML | Leave a comment

XML Boiler project reached an important milestone

XML Boiler project reached an important milestone: To make the first release it remains to debug it. (Also need to create particular XML processing scripts to make it useful.)

XML Boiler is the implementation of my Automatic transformation of XML namespaces specification, which is going to revolutionarize processing of XML documents both locally and on the Web.

Please donate to porton@narod.ru at PayPal.

Posted in Linux/Unix, Programming, XML | Leave a comment

Dear Martin,

This is a letter to Martin Fowler, which I also publish in my blog.

I am rather wondered why you don’t do any mention in your article

https://www.martinfowler.com/articles/injection.html

about the following problem:

Real classes which use dependency injection very often may need to pass some of their dependencies to implementation classes which they depend on.

This may lead to increase of the number of dependencies and make code somehow hard to write and read. Another problem is that while implementation of a class changes (say to make it more advanced), new dependencies may appear leading to such inconveniences as changing constructors’ signatures.

I feel that one of the best solutions is to group related dependencies into a record (if to use Pascal term) or a structure (if to use C/C++ term), like as this fragment of my ongoing open source project written in Python:

class ExecutionContext(object):
    def __init__(self, logger, translations):
        """
        :param logger: logger
        :param translations: usually should be gettext.GNUTranslations
        """
        self.logger = logger
        self.translations = translations

This way I can pass one object ExecutionContext instead of two objects (the logger and the translations) into constructors. These objects are to be then grouped into even greater objects, etc.

Do you think it is a good idea?

Posted in Programming | Leave a comment

Finished translation of namespace transformer to Python

I originally started to write my XML Boiler software in Ada. Ada compiler has too many bugs.

I switched to Java. I discovered for myself that Java byte arrays are limited to about 4GB of bytes, this makes problematic processing of big XML files. I switched to Python.

Now I have finished translating it from Java to Python. Now I can continue to implement features. Yet much work remains.

Posted in Programming, XML | Leave a comment

Library to spawn a process with given input and receive its output

I have created a C library to span a process with given input and receive its output.

One cannot just write to stdin of a process and then read its stdout through pipes, because this way it may lead to a deadlock.

Instead use my library:

It is an alpha release, tested on Linux.

During its development I managed to crash Linux: https://bugzilla.kernel.org/show_bug.cgi?id=198549

Posted in Linux/Unix, Programming | Tagged , , , , , , , , | Leave a comment

A new problem appeared writing automatic XML transformations

This is about Automatic transformation of XML namespaces.

Previously I divided all transformations into two groups:

  1. with a given source and target namespace (as converting DocBook into HTML);
  2. with only source given but not the target (as for XInclude).

Today I’ve realized that it is a wrong division. Instead we need to split into:

  1. transformations for transforming from a specified source to a specified target;
  2. transformations for which transformation should happen if we have correct source namespaces, not depending on which is the target namespace.

The second kind is some kind of “reducing” as XInclude reduces one XML file to another (and this usually are transformation in “right” direction even if the destination namespace is not in our list of destination namespaces). The “reduce” is defined as an operation which should always happen over an XML file even if the target namespace is not in our set of expected target namespaces.

But “reducing” is not absolute. Sometimes we may want to reduce from a given source namespace and sometimes not. Reduce is some relative property: The same namespace may be considered as a source of reduce and sometimes not. For example one may want to convert XInclude tags and attributes into another XML namespace which describes inclusion (instead of reduce).

We are yet to understand relative of what is the reduce. How we specify when a reduce is in our set of reduces and when no.

Sorry if I explained not quite clearly, this is a work in progress.

This is a new hard (fundamental) problem appeared before me while developing Automatic transformation of XML namespaces. I have solved some other fundamental problems after some despair and hope to solve this problem too.

Posted in XML | Leave a comment