Plunder on behalf of Sirius is “Planning for tomorrow”? Using the name of Standard Life and fake/false payslips?

Summary: The facilitator of a scam was contacted the other day (Integrity Financial Management Ltd.); their staff too seems to have played a role in the pension fraud, so we’ve contacted Integrity Financial Management directly, however it chose not to respond and instead pretended not to be aware of anything — a major blunder and an actual crime against GNU/Linux administrators and programmers

INITIAL CONTACT was made the other day with Integrity Financial Management Ltd. That firm may have facilitated the crimes of Sirius ‘Open Source’ and it needs to know about it. We have the names of the people who managed these accounts.

You may not be aware of this, but your firm facilitated fraud at Standard Life

http://techrights.org/2023/04/17/fraud-at-sirius-open-source-with-integrity-financial-management/

Myself and former colleagues are still trying to hold accountable the culprits

http://techrights.org/wiki/Crimes_of_Sirius_Open_Source#Fraud_Investigation

Why did you issue all this material to us? Why did you facilitate theft of pension funds?

Please contact us as soon as possible to clarify the matter.

Just because they’re not replying does not mean they’re off the hook. This is a typical business strategy; they try to ignore anything that’s not convenient to them, hoping it would miraculously go away.

As we also noted earlier this week, Sirius had engaged in financial fraud and it is now registered at the address of the accountant, so that’s another potential legal liability for them.

So far I’ve spent about 10 hours on the phone all in all. And even when each time you phone you know exactly what needs to be achieved and try to get to that as fast as possible, they delay and obstruct. It’s an actual method, tiring down the complainant or bleeding people to death with phone bills (like legal bills/lawyer fees as barrier). It’s a bit like a network of organised crime made to over up its own doing. It is well coordinated to dodge accountability. Business as usual.

As an example of endless delays, consider NOW: Pensions. I contacted them back in January and it took until now (late April) to finally receive a letter of assurance that can be regarded as satisfactory.

In fact, sent just after 4PM yesterday (by E-mail):

Dear Dr Schestowitz,

NOW: Pensions Trust (“the Scheme”)

I write about your complaint. I would like to thank you for your patience while we have investigated this matter and would like to apologise for any inconvenience caused.

I can confirm we sent a letter (the information in the letter applies to all members in a NOW Pension Scheme) to your home address on the 12^th of April 2023. For reference I have attached the correspondence to this email.

This has been protected with a case-sensitive password. The password is your national insurance number followed by an exclamation mark. [...]

Should you consider that this does not bring the matter to a conclusion, you can request that the Trustees review the matter through the Internal Dispute Resolution Process (IDRP).

[...]

Yours sincerely

Craig Aitken

NOW: Pensions Trust Administration Team

And here is a mildly-redacted (home address) PDF of the document. We redacted a photograph of the physical thing earlier this week. Why did it take so long to issue such a letter? With NOW: Pensions alone my wife and I must have spent about 4 hours over the telephone; it costs a fortune as they don’t have a free line and they keep you waiting on the line a lot (when they don’t leave you pressing buttons and ‘speaking’ to a bot).

Video download link | md5sum 517c825e6b2b4ff488a8c7557ed7b5ce
Management Always Right
Creative Commons Attribution-No Derivative Works 4.0

Summary: Sirius ‘Open Source’ has a seemingly very common problem; managers cannot be held accountable and even when shown that they failed at something, instead of apologising or taking actions against themselves they resort to accusing/blaming the reporter

TWELVE years ago the management at Sirius was a lot better. I was there. I saw it. Managers were typically technical people (like programmers and sysadmins). Things have changed though.

In recent years managers were just self-styled ‘managers’ or “professional managers” with experience in babysitting (literally).

As noted here a few hours ago, bringing a concrete example to the table, managers had made bad technical decisions and then refused to admit that. The evidence does not matter! It’s all about one’s pride. It’s about protecting brands^*.

Moreover, in that same example, it should be clear that staff wasn’t properly informed or trained; then, a falsified timeline was constructed for post hoc-type cover-up.

This example is about a year old, so in relative terms it is recent. If you work in a company that behaves in this way, consider leaving. Things won’t improve as this sort of attitude repels geeks.
_______
^* At Sirius, Google and AWS/Amazon were stubbornly defended no matter what (also Slack and Clownflare to a lesser degree). Readers of Techrights would likely be going one step ahead, correctly guessing some companies (not Sirius!) or even universities/governments (public sector, accountable to their citizens) which made a move to Microsoft would be ‘religiously’ defending bad decisions/choices (bribes often play a role, as Microsoft whistleblowers have repeatedly demonstrated in the recent past).

And whenever things fail, as always happens (Microsoft products are even defective by design), Microsoft just pushes them more Microsoft as the supposed solution. More sales! The culprits who brought Microsoft to the business/government want to “prove” it’ll work; so they pay Microsoft some more, albeit not at a personal expense. It’s a vicious cycle. Everyone loses, except Microsoft. And if only everything ran on Microsoft, they insist, things would be ‘optimal’ (until the next ransomware attack).

As an associate put it (to paraphrase), the problem is always that there wasn’t sufficient faith in Microsoft and that is always solved by buying TheNextVersion(tm) and MORE of it. For decades the cycle has been the same, namely it’d work if only they could achieve 100% Microsoft integration. Once that happens, the target goal posts move, and it would work if only they could purchase TheNextVersion, and if that happens before they run out of money, then the goals posts move again. At that point it becomes, it’d work if only they had the right Microsoft training. Then by that time, the $TheNextVersion has become $ThePreviousVersion and that part of the cycle starts again. And yet they still blame outright collapses on “Linux people” and your average worker agrees to believe that excuse. The problem is not new, it as it goes back to the 1990s. But for a recent example look at Aaron Swartz’s blog post about Conde Nast and why he had no choice but to walk out the door and not look back.

Summary: This coming Tuesday is a special day; 39 years since the message (announcement) below, so next year it’s 40 (a time leap in the context of software development; not much stuff lasts this long)

From CSvax:pur-ee:inuxc!ixn5c!ihnp4!houxm!mhuxi!eagle!mit-vax!mit-eddie!RMS@MIT-OZ
From: RMS%MIT-OZ@mit-eddie
Newsgroups: net.unix-wizards,net.usoft
Subject: new Unix implementation
Date: Tue, 27-Sep-83 12:35:59 EST
Organization: MIT AI Lab, Cambridge, MA

Free Unix!

Starting this Thanksgiving I am going to write a complete
Unix-compatible software system called GNU (for Gnu's Not Unix), and
give it away free(1) to everyone who can use it.
Contributions of time, money, programs and equipment are greatly
needed.

To begin with, GNU will be a kernel plus all the utilities needed to
write and run C programs: editor, shell, C compiler, linker,
assembler, and a few other things.  After this we will add a text
formatter, a YACC, an Empire game, a spreadsheet, and hundreds of
other things.  We hope to supply, eventually, everything useful that
normally comes with a Unix system, and anything else useful, including
on-line and hardcopy documentation.

GNU will be able to run Unix programs, but will not be identical
to Unix.  We will make all improvements that are convenient, based
on our experience with other operating systems.  In particular,
we plan to have longer filenames, file version numbers, a crashproof
file system, filename completion perhaps, terminal-independent
display support, and eventually a Lisp-based window system through
which several Lisp programs and ordinary Unix programs can share a screen.
Both C and Lisp will be available as system programming languages.
We will have network software based on MIT's chaosnet protocol,
far superior to UUCP.  We may also have something compatible
with UUCP.


Who Am I?

I am Richard Stallman, inventor of the original much-imitated EMACS
editor, now at the Artificial Intelligence Lab at MIT.  I have worked
extensively on compilers, editors, debuggers, command interpreters, the
Incompatible Timesharing System and the Lisp Machine operating system.
I pioneered terminal-independent display support in ITS.  In addition I
have implemented one crashproof file system and two window systems for
Lisp machines.


Why I Must Write GNU

I consider that the golden rule requires that if I like a program I
must share it with other people who like it.  I cannot in good
conscience sign a nondisclosure agreement or a software license
agreement.

So that I can continue to use computers without violating my principles,
I have decided to put together a sufficient body of free software so that
I will be able to get along without any software that is not free.


How You Can Contribute

I am asking computer manufacturers for donations of machines and money.
I'm asking individuals for donations of programs and work.

One computer manufacturer has already offered to provide a machine.  But
we could use more.  One consequence you can expect if you donate
machines is that GNU will run on them at an early date.  The machine had
better be able to operate in a residential area, and not require
sophisticated cooling or power.

Individual programmers can contribute by writing a compatible duplicate
of some Unix utility and giving it to me.  For most projects, such
part-time distributed work would be very hard to coordinate; the
independently-written parts would not work together.  But for the
particular task of replacing Unix, this problem is absent.  Most
interface specifications are fixed by Unix compatibility.  If each
contribution works with the rest of Unix, it will probably work
with the rest of GNU.

If I get donations of money, I may be able to hire a few people full or
part time.  The salary won't be high, but I'm looking for people for
whom knowing they are helping humanity is as important as money.  I view
this as a way of enabling dedicated people to devote their full energies to
working on GNU by sparing them the need to make a living in another way.


For more information, contact me.
Arpanet mail:
  RMS@MIT-MC.ARPA

Usenet:
  ...!mit-eddie!RMS@OZ
  ...!mit-vax!RMS@OZ

US Snail:
  Richard Stallman
  166 Prospect St
  Cambridge, MA 02139

ECADES ago somebody told me that changing employers very often is a sign of weakness. Several times later I’d hear the same thing, which follows common sense. Loyalty to an employer or devotion to some particular path shows both a careful choice (of employer) and persistence rather than adventurism. The same goes for housing or residency. Some people move from place to place very often, having to relearn locations of things, spending a lot of time on paperwork, having to meet new people (and losing touch with old friends and colleagues).

When it comes to my current employer, this past week marked 10 years of me working there. There were better times and worse time, both for myself and for the employer.

For the first time in my life I can say that I’ve worked in the same company for over a decade. For just over a year (or about 2 years) I’ve been able to say that I’m the most “senior” (in terms of duration) regular employee there, sans the founder/CEO, who established the company way back in 1998. In a sense, this also means that when I joined the company (with about 20 people in it back then) I was the “latest recruit” and all those people whom I joined are now gone, except the CEO. It’s an interesting situation to be in.

Will I work another 10 years in the same company? It’s hard to tell. The thing I do like about it is that it respects my freedom of expression (it tells off Microsoft when they try to cause issues by phoning the CEO!) and software freedom in general. I realise that many people are forced to use Windows, at least sometimes, and not everyone is permitted to work from home all the time. I’ve worked from home for 14 years now.

T IS now pretty much confirmed that GitHub has sold out to help Microsoft cause further damage to Free software (FOSS). In a nutshell, Microsoft’s motivation is shallow enough to see:

1. Microsoft wants to pretend FOSS was never the competition (this causes confusion which serves Microsoft’s bottom line)
2. Microsoft will lie to officials who sign contracts about being an “open source company” (all of Microsoft’s core software remains proprietary with malicious features like surveillance and DRM)
3. Buying out, controlling the competition
4. Patent blackmail, bribery and other attacks on FOSS carry on while Microsoft pretends that all is well (“we come in peace”)

So it’s time to devalue GitHub; it won’t make it any cheaper for Microsoft to buy at this stage (they agreed on the price).

If you have substantial work on the site, migrate away. Here, for example, is how to import your project from GitHub to GitLab.

Then it’s time to delete.

Log in, then enter the following address: https://github.com/settings/admin

Follow these steps:

They then send out an E-mail:

Subject: [GitHub] Account deletion

This email is to confirm that you’ve deleted your account ‘schestowitz’ from GitHub. Your repositories and content have been deleted from the system. If you were on a paid plan, you will not be billed again. We’re sorry to see you go. You can reply directly to this email if you have any questions or feedback, we’d love to hear from you.

Tell others to do the same thing. I will soon urge my wife (when she wakes up) to do the same. Only fools (not her) believe lies like “Microsoft loves Linux”.

ESTERDAY I ranted about PhpWiki, blaming PHP for the most part. Why? My Web host has ‘broken’ a lot of the software that I run in this Web site. Some software has relentlessly and happily been running for a decade or more. It is a lot of software (all in all about 20 databases), some of which I have manually patched or changed/hacked whenever the host upgraded PHP. It is a lot of work. It is a lot of inevitable maintenance. I blame PHP. The latest upgrade is to PHP 5.3. The host reverted back to the older version (5.2) for two weeks (a sort of an ultimatum) to help me sort things out before this upgrade is permanently imposed. PhpWiki was not the only cause of issues, but it was part of it that took a whole noon plus afternoon (almost as much time as it would take to just rebuilt it all manually). While I was able to (eventually) make a minor upgrade (from a 2006 version to a 2008 version, not to the current or even recent versions) it remains unclear why PHP decided to not be backward-compatible. It is a total nightmare for sites for have a lot of PHP code, especially if their maintainers are not full-time PHP developers or are ingratiating components of software which is no longer actively maintained. PHP is risky to choose or work with. I learned this the hard way. It may be normal for proprietary frameworks to do this, but why FOSS?

Today I successfully upgraded two PHP-Nuke sites (thankfully there were upgrade scripts which worked reasonably well) and then I struggled for a whole with Gallery 2, where the upgrade process is complicated and very long, resulting in a sub-optimal outcome (e.g. no thumbnails and no tolerance of a perfectly fine ImageMagick installation). People without very advanced knowledge of UNIX and other such skillsets won’t manage to keep their photo galleries up to date. This is a real travesty. This is the catalyst of ‘Web rot’.

What I’ve identified and am eager to summarise after two days of frustrating work is this:

1. PHP-based software cannot be counted on, especially if it’s intended to run for years (the long run)
2. Choosing less established PHP-based software is risky as it might cease being maintained
3. cPanel does give access to PHP error logs, but this is not too trivial to find
4. Internal server errors can be due to restrictive Web hosts who deny access to scripts based on their UNIX-style permissions
5. It is always better to install software from front-end scripts, such as those found in Fantastico
6. Don’t use too many pertinent bits of software; diversity can be a nightmare to deal with
7. When patching existing software, keep a log/record of everything that has changed
8. If a lot of people across the Web complain about upgraders, importers, exporters, etc. then it’s better not to bother with them at all as they won’t work correctly and just waste time
9. Check carefully and exhaustively a good test set of data following upgrade, or missing data will only be identified several years down the line when backups are too hard to find and revert to (I just found out that this happened to me)
10. Use static HTML where you deem it suitable because the cost of maintaining/upgrading PHP is often too high to justify such a reliance

I am fed up with PHP. One cannot just install something and let it run along for years. It’s a lot of work to maintain and sometimes there’s loss of data, induced by improper upgrade paths and mistakes/accidents.

oday I wrote the following bash script (note: written for 16 cores although it can be modified for more or for less), which splits SQL operations, preceded by “ [NUMERIC WEIGHT] |“. This helps assure a nice distribution of load on the bare metal. This might be reusable, so I decided to post it on my site.

IFS=$'\n'

CORE0LOAD=0
CORE1LOAD=0
CORE2LOAD=0
CORE3LOAD=0
CORE4LOAD=0
CORE5LOAD=0
CORE6LOAD=0
CORE7LOAD=0
CORE8LOAD=0
CORE9LOAD=0
CORE10LOAD=0
CORE11LOAD=0
CORE12LOAD=0
CORE13LOAD=0
CORE14LOAD=0
CORE15LOAD=0

WEIGHT=0;

echo Starting...

for line in $(cat ~/Desktop/input)
# while read line < ~/Desktop/input
# for line in `cat ~/Desktop/input`
do
# echo -e line="$line"
# $line="$line"
# echo $line
# exit
	if [ $CORE0LOAD -lt $CORE15LOAD ]
	then
# echo $line
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE0LOAD+$SCORE)) > total
		read SCORETOTAL < total
# echo $SCORETOTAL
		CORE0LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line >> core0.sh



	elif [ $CORE1LOAD -lt $CORE2LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE1LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE1LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core1.sh
	elif [ $CORE2LOAD -lt $CORE3LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE2LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE2LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core2.sh
	elif [ $CORE3LOAD -lt $CORE4LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE3LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE3LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core3.sh
	elif [ $CORE4LOAD -lt $CORE5LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE4LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE4LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core4.sh
	elif [ $CORE5LOAD -lt $CORE6LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE5LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE5LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core5.sh
	elif [ $CORE6LOAD -lt $CORE7LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE6LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE6LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core6.sh
	elif [ $CORE7LOAD -lt $CORE8LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE7LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE7LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core7.sh
	elif [ $CORE8LOAD -lt $CORE9LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE8LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE8LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core8.sh
	elif [ $CORE9LOAD -lt $CORE10LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE9LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE9LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core9.sh
	elif [ $CORE10LOAD -lt $CORE11LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE10LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE10LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core10.sh
	elif [ $CORE11LOAD -lt $CORE12LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE11LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE11LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core11.sh
	elif [ $CORE12LOAD -lt $CORE13LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE12LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE12LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core12.sh
	elif [ $CORE13LOAD -lt $CORE14LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE13LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE13LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core13.sh
	elif [ $CORE14LOAD -lt $CORE15LOAD ]
	then
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE14LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE14LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line  >> core14.sh
	else
# echo $line
		echo $line > current_line
		cut -b 1-13 current_line > current_number
		read SCORE < current_number
		echo $(($CORE15LOAD+$SCORE)) > total
		read SCORETOTAL < total
		CORE15LOAD=$((SCORETOTAL))
		cut -b 16-10000 current_line >> core15.sh
	fi
done
echo Ended...
 

Now, each file contains operations to be run on one core, without conflict (order or load imbalance).