Ciro Santilli @cirosantilli  40

Some linker related answers by Ciro Santilli:

Their system is quite good actually. Not as good as a GitHub repo with all the tests made explicit. But still pretty good.

The perfect Middle Way between command-line interfaces and GUIs. A thing of great beauty.

Basically means "company with huge server farms, and which usually rents them out like Amazon AWS or Google Cloud Platform

Highly managed, you don't even see the Docker images, only some higher level JSON configuration file.

These setups are really convenient and cheap, and form a decent way to try out a new website with simple requirements.

ISO is the main culprit of this bullshit, some notable examples related to open source software:

The only low level thing that escaped this was OpenGL via Khronos, what heroes those people are.

How the hell are you supposed to develop an open source implementation of something that has a closed standard?

Not to mention open source test suites, that would be way too much to ask for, those always end up being made by some shady small companies that go bankrupt from time to time, see e.g. .

If you are going to do closed source, at least do it like this.

Basically the opposite of need to know for software.

Closed source on offline products used by millions of people is evil, when you could just have those for free with open source software! Thus Ciro's hatred for Microsoft Windows and MacOS (at least userland, maybe).

TODO why it is optimal: physics.stackexchange.com/questions/149214/why-is-the-carnot-engine-the-most-efficient

Basically the same as classical limit, but more for quantum mechanics.

Some anecdotes.

Ciro Santilli never splits up functions unless there is more than one calling point. If you split early, the chances that the interface will be wrong are huge, and a much larger refactoring follows.

If you just want to separate variables, just use a scope e.g.:

int cross_block_var;

// First step.
{
    int myvar;
}

// Second step.
{
    int myvar;
}

Ciro has seen and had to deal with in his lifetime with two projects that had like 3 to 10 git separate Git repositories, all created and maintained by the same small group of developers of the same organization, even though one could not build without the other. Keeping everything in sync was Hell! Why not just have three directories inside a single repository with a single source of truth?

Another important case: Linux should have at least a C standard library, init system, and shell in-tree, like BSD Operating Systems, as mentioned at: Section "Linux".

A slow development test cycle will kill your software.

New developers won't want to learn your project, because they would rather shoot themselves.

This means that build time, and the time to run tests, must be short.

5 seconds to rebuild is the maximum upper limit.

Of course, at some point software gets large enough that things won't fit anymore in 5 seconds. But then you must have either some kind of build caching, or options to do partial builds/tests that will bring things down to that 5 second mark.

You also have to spend some time profiling execution and build from scratch times.

A slow build from scratch will mean that your continuous integration costs a lot, money that could be invested in a new developer!

It also means that people won't bother to reproduce bugs on given commits, or bisect stuff.

One anecdote comes to mind. Ciro Santilli was trying to debug something, and more experience colleague came over.

To reproduce a problem, ciro was running one command, wait 5 seconds, run a second command, wait 5 seconds, run a third command:

The first thing the colleague said: join those three commands into one:And so, Ciro was enlightened.

Whenever someone asks:you don't need to read anymore, just point them to this page immediately. Virtualization for the win.

Sometimes you are really certain that something is a required substep for another thing that is coming right afterwards.

When things are this concrete, fine, just do the substep.

But you have to always beware of cases where "I'm sure this will be needed at some unspecified point in the future", because such points tends to never happen.

YAGNI is so fundamental, there are several closely related concepts to it:

The software engineer phrasing of simplicity is the ultimate sophistication.

Like all other principles, it is not absolute.

But it is something that you should always have on the back of your mind.

You aren't gonna need it is closely related, as generally the extra unnecessary complications are set in place to accommodate useless features that will never be needed.

The trivial takes a few hours.

The easy takes a week.

And what seemed hard takes a few hours.

As "deadlines" approach, feature sets get cut down, then there are delays, and finally a feasible feature set is delivered some time after the deadline.

The only deadlines that can be met are those of tasks which have already been done but not announced.

This is of course Hofstadter's law.

On the other hand, as a colleague of Ciro once mentioned, it is also known that the time it takes for a task to be done expands without limits to match the deadline. And therefore, without deadlines, tasks will take forever and never get done.

And so, in a moment, perceiving this paradox, Ciro was enlightened.