Mais qui est Guillaume Rozier pour bénéficier de tant de clameurs médiatiques ?

Il a inventé ou vaccin ou un traitement ? Non

Il fait avancer la science directement ou indirectement ? Non

Il sort des chiffres que personne ne sort ? Non (note : les chiffres sur son site sont ceux du gouvernement, ceux rendus publiques)

Il fait des graphiques incroyables ? Non

Il permet de mieux comprendre l'épidémie par la mise en ligne de graphiques pertinents ? Non


Mais en fait, que fait Guillaume Rozier ?

Je me pose toujours la question.

Peut-être un début de réponse, un peu cynique je l'admet : si vous allez sur son site covidtracker, vous verrez au milieu d'un capharnaum de graphiques peu lisibles et de boutons menant vers d'autres graphiques, que les titres font souvent référence à cette notion de taux d'incidence. Sous toutes ses formes, par exemple lorsqu'on parle de positivité, c'est la même chose. Il se trouve qu'il est admis aujourd'hui que le taux d'incidence n'est pas pertinent pour le suivi de l'épidémie, pour de nombreuses raisons : 1) très lié au nombre de tests 2) comptages multiples des tests pour la même personne 3) décorrélation entre contamination et contagiosité 4) décorrélation entre contamination et hospitalisation.
En fait le taux d'incidence devrait être renommé taux d'indécence.
Et celui-là il monte tous les jours, ça se voit.

Vous entendez une critique laudative sur Guillaume Rozier (ou sur le taux d'indécence) ? Passez votre chemin.

Filling cells is an extension of paste where a source area gets duplicated to a larger area multiple times both horizontally and vertically, hence the fill.


Creating a range fill


As an example, you could have content at row 3 that according to some scenario needs to be duplicated in rows 6 to 8. If the paste/pasteTo function is used, this needs iteration over rows 6 to 8. But using fill, a single statement will do :

C/C++ code

worksheet->Rows[L"3:3"]->Range->FillTo(worksheet, worksheet->Rows[L"6:8"]->Range, xlsgen::pasteoption_valuesandformattingandformulas);

Another example is range C3:F4 that gets used in order to fill range B5:Z8 of another worksheet :

C/C++ code

worksheet->NewRange(L"C3:F4")->FillTo(worksheet2, worksheet2->NewRange(L"B5:Z8"), xlsgen::pasteoption_valuesandformattingandformulas);

Windows 10 version 20H2 messes up drivers.

So far, ever since this mandatory update went through,

- my printer stopped working completely, alerting that there was a communication problem as if there was no USB cable in between. Fix : uninstall then install the printer driver again. Updating the driver did not do anything.

- my graphics card would cause computer hang in some games, randomly. Again, the fix : uninstall then install the graphics card driver again.

So far it seems all good, but should this be a normal situation ? Should wrecking someone's computer in a mandatory update be the new standard ? What if I were unable to diagnose and fix things ? And what if Windows 10 20H2 had broken the network driver so I wouldn't be able to go online and find the driver ?

Build 4.9.0.8 of xlsgen fixes a problem for generating custom report filters in pivot tables. The bug appeared in XLSX and XLSB files.

Build 4.9.0.7 of xlsgen adds support for Rust as a programming language.

xlsgen supports Rust as a programming language which allows to build rust applications of any size and complexity.


Rust in xlsgen
Rust is a functional language popularized in a number of environments and places, and it turns out that it can also make low-level calls. The xlsgen install package takes advantage of this and comes with an interface layer (called xlsgen.rs) which exposes the entire object model to Rust code environments. Both enumerated types and interfaces are available.

It is assumed that the basic Rust development or runtime environment is installed on the computer. The xlsgen interface layer does not use any particular feature of a recent Rust version, so most likely any Rust version of the language and environment is compatible with it.
In fact, what xlsgen relies on is the Rust winapi crate, which provides a number of Windows types and macros that make it easier to expose and handle.
Here is how a simple Rust program looks like in structure :

- src
   |
   |- main.rs (your code goes here)
   |- xlsgen.rs (xlsgen interface layer (available from the xlsgen install package))
- Cargo.toml (known dependency declaration (winapi))

Here is how you build it :

cd \tmp\rust\simple
cargo build

Here is how you run it :

cd \tmp\rust\simple
cargo run

During the first run, the package manager will download a compatible version of the winapi crate in order to meet the dependency specifications, so the compuer where this runs must be online and ready to download stuff, even though this stuff has nothing to do with xlsgen.
xlsgen.rs on the other hand is part of the xlsgen install package, so it can be copied over in your source code folder structure. xlsgen.rs is computer-generated by a tool that was designed to convert a COM IDL object model to a Rust compatible object model.
Rust can execute low-level statements, but because of what they are those statements have to be enclosed inside an unsafe section.
Here is how you put a number in cell B4 :

  let _hr = unsafe { 
               (*p_worksheet).put_float(4, 2, 4.5);
            };	

The return value of any call is a HRESULT, i.e. a value of zero means everything went fine, and you can look up winerr.h to find the list of existing HRESULT errors (for instance 0x80070057 = invalid parameter).
Before you can load xlsgen in memory, the COM library must be loaded, which means a paired CoInitialize/CoUninitalize call.
In Rust, all depending types must be declared, tha's why your typical application will include statements such as :

use winapi::{Class, Interface};

Last but not least, Rust macros can help group code patterns together. For instance, if you'd like to create a pointer to an object, initialize to null, you would declare a macro like this :

macro_rules! new_pointer {
     ($param:ident, $type:ty) => {let mut $param: *mut $type = unsafe { std::mem::zeroed() };}
}

And then you would use this macro like this :

new_pointer!(p_engine, xlsgen::IXlsEngine);

Here is a Rust sample application in full that creates a spreadsheet with two sheets, puts a couple numbers in it and reads back the content of a cell. It's available in the /samples folder of the xlsgen install :

use winapi::um::winnt::{LPWSTR};
use winapi::{Class, Interface};
use std::ffi::{OsStr, OsString};
use std::os::windows::ffi::OsStrExt;
use std::os::windows::ffi::OsStringExt;
use std::slice;

pub mod xlsgen;


// *** MACROS begin here ***

macro_rules! retVal {
    ($param:ident) => {&mut $param as *mut _ as *mut _}
}

macro_rules! new_pointer {
    ($param:ident, $type:ty) => {let mut $param: *mut $type = unsafe { std::mem::zeroed() };}
}

macro_rules! release_pointer {
    ($param:ident) => { unsafe { (&mut * $param).Release() }; }
}

macro_rules! release_bstr_string {
    ($param:ident) => { unsafe { winapi::um::oleauto::SysFreeString( $param as LPWSTR ) }; }
}


// *** MACROS end here ***

// unicode strings (Rust stores strings using UTF8 encoding, not UTF16) so we have to convert back and forth

fn to_wstring(string: &str) -> Vec<u16> {
    let mut v: Vec<u16> = OsStr::new(string).encode_wide().collect();
    v.push(0); // EOL
    v
}

fn from_wstring(string: LPWSTR) -> String {
    let string_slice = unsafe {
        let len = winapi::um::oleauto::SysStringLen(string);
        slice::from_raw_parts(string, len as usize)
    };

    OsString::from_wide(string_slice).into_string().unwrap()
}


fn main() {

    println!("step1");

    let _hr = unsafe { winapi::um::objbase::CoInitialize(std::ptr::null_mut()) };

    println!("step2");

    new_pointer!(p_engine, xlsgen::IXlsEngine);

    let _hr = unsafe { winapi::um::combaseapi::CoCreateInstance(
			&xlsgen::XlsEngine::uuidof(), 
			std::ptr::null_mut(), 
			winapi::shared::wtypesbase::CLSCTX_INPROC_SERVER, 
			&xlsgen::IXlsEngine::uuidof(), 
			retVal!(p_engine))
	        };

    println!("step3 {}", _hr);

    new_pointer!(p_workbook, xlsgen::IXlsWorkbook);

    let _hr = unsafe { (*p_engine).new(to_wstring("d:\\tmp\\eer.xlsx").as_ptr(), retVal!(p_workbook)) };

    new_pointer!(p_worksheet1, xlsgen::IXlsWorksheet);

    let _hr = unsafe { (*p_workbook).addworksheet(to_wstring("sheet 1").as_ptr(), retVal!(p_worksheet1)) };	

    new_pointer!(p_worksheet2, xlsgen::IXlsWorksheet);

    let _hr = unsafe { (*p_workbook).addworksheet(to_wstring("sheet 2").as_ptr(), retVal!(p_worksheet2)) };	

    println!("step4");

    let mut i_wksht_count : i32 = 0;

    let _hr = unsafe { (*p_workbook).get_worksheetcount(&mut i_wksht_count) };

    println!("step4a {}, wkshtCount = {}", _hr, i_wksht_count);

    unsafe { (*p_workbook).put_factorizedstringsmode(true) };

    let mut b_factorized : bool = false;

    let _hr = unsafe { (*p_workbook).get_factorizedstringsmode(&mut b_factorized) };

    println!("step4ab {}, bFactorized = {}", _hr, b_factorized);

    // write some content
    for r in 1..10 {
       let _hr = unsafe { (*p_worksheet1).put_label(r, 2, to_wstring("hello world").as_ptr()) };	
     }

    // read some content

    println!("step4b");

    new_pointer!(cell_string, LPWSTR);

    println!("step4c");

    let _hr = unsafe { (*p_worksheet1).get_label(3, 2, retVal!(cell_string)) };	

    println!("step5");

    println!("cell value is : {}", from_wstring(cell_string as LPWSTR));

    println!("step6");

    new_pointer!(p_richlabel, xlsgen::IXlsRichLabel);

    println!("step6b");

    let _hr = unsafe { (*p_worksheet1).newrichlabel(retVal!(p_richlabel)) };	

    println!("step6c {}", _hr);

    let _hr = unsafe { (*p_richlabel).put_htmllabel(to_wstring("<span>hello <b>world</b></span>").as_ptr()) };	

    println!("step6d");

    let _hr = unsafe { (*p_worksheet1).put_richlabel(1, 4, p_richlabel) };	

    println!("step6e");

    let _hr = unsafe { (*p_workbook).close(); };

    println!("step7");

    release_bstr_string!(cell_string);
    release_pointer!(p_worksheet1);
    release_pointer!(p_worksheet2);
    release_pointer!(p_workbook);
    release_pointer!(p_engine);

    unsafe { winapi::um::combaseapi::CoUninitialize() };

    println!("step8");

}

Here is an excerpt from xlsgen.rs :

(...)

RIDL!{#[uuid(0xD97500CF,0x37CC,0x48fd,0x87,0x72,0x0E,0xBC,0x8F,0x8A,0x93,0x76)]
interface IXlsEngine(IXlsEngineVtbl): IDispatch(IDispatchVtbl) {
    fn new(    // creates a new .xls/.xlsx file with the name (filename or filepath) passed in parameter.
        excelfilename : LPCWSTR,
        workbook : *mut *mut IXlsWorkbook,
    ) -> HRESULT,

(...)

RIDL!{#[uuid(0x12B7B224,0xC026,0x4eb6,0xBA,0x94,0xC4,0x9B,0x91,0x6F,0x77,0x40)]
interface IXlsWorkbook(IXlsWorkbookVtbl): IDispatch(IDispatchVtbl) {
    fn addworksheet(    // creates a new worksheet with the name passed in parameter. The following characters are forbidden : / \\ : * [ ], and the name must be less than 32 characters long.
        name : LPCWSTR,
        worksheet : *mut *mut IXlsWorksheet,
    ) -> HRESULT,

(...)

RIDL!{#[uuid(0xB150D9DA,0x1F10,0x4850,0x9A,0xBB,0x76,0xD9,0x95,0x47,0x96,0xEE)]
interface IXlsWorksheet(IXlsWorksheetVtbl): IDispatch(IDispatchVtbl) {
    fn put_label(    // puts a label in a cell.
        row : i32,
        col : i32,
        label : LPCWSTR,
    ) -> HRESULT,

Build 4.9.0.6 of xlsgen fixes another problem related to relative cells and inserting/deleting rows and columns. This time the problem could corrupt the Excel file without producing an error message, and was related to rebuilding internal shared formulas.

Si le vaccin Astra Zeneca pose autant de problèmes, c'est qu'on oublie un peu vite que son homologation a été "en urgence" (en anglais fast-track), ce qui permet à un vaccin candidat n'ayant pas garanti de toutes ses caractéristiques d'être utilisé en urgence.
Dès lors, ceux qui sont vacciné avec ce candidat sont des cobayes.
Techniquement il faudrait attendre que les essais sont menés à leur terme puis que la phase d'analyse soit faite.
Mais on préfère prendre des risques, et casser par la même la sainte religion du vaccin qui ne perturbe pas la santé d'une personne en bonne santé.

Build 4.9.0.5 of xlsgen fixes a problem related to manipulating rows/columns with formulas using partially relative rows or columns, such as R$170 (R is relative as a column, 170 is an absolute reference due to the presence of the $ prefix). Inserting, deleting rows or columns would corrupt such formulas. There was no problem with cell references either not relative at all (for instance $A$5), or both relative for rows and columns (for instance A5).

Aujourd'hui les réseaux sociaux sont synonymes de censure. Et de censure privée au nom du bien. C'est une horreur.

La censure doit être le fait non de celui qui est propriétaire des tuyaux, mais de celui qui ne veut pas être importuné, bref de l'individu. Si l'individu veut pouvoir ne pas voir le contenu qui concerne une personne, un groupe de personnes, un sujet, un raisonnement, voire pourquoi pas des combinaisons de mots, grand bien lui fasse, et la plateforme doit lui fournir ces outils à titre individuel mais sans jamais interférer sur les souhaits de l'individu.

C'est ça une plateforme qui protège la liberté d'expression. L'équivalent de tuyaux dans lesquels circule le courant électrique, l'eau, le gaz, ...

Aujourd'hui ce que nous avons c'est le propriétaire des tuyaux qui, au nom du bien, bien défini par des minorités actives, qui a droit à ce qui circule dans les tuyaux. C'est arbitraire et ça donne un pouvoir exhorbitant à ces minorités actives. Bref ça leur donne le pouvoir, à ces minorités actives, de décider qui a le droit de voir et d'entendre quoi.

L'informatique a une solution contre ce manque flagrant de liberté d'expression. Mettons là en oeuvre et refusons l'informatique centralisée.

TwitchTracker is one of those stat sites derived from Twitch where you can see charts of what has been going on about a particular stream over a day period or the entire streamer life period. Here is one example with average viewers and hours streamed, spanning over the streamer life period :


Chart from TwitchTracker : there is something hard to understand

There is something hard to understand, which is the fact that it's impossible to tell to which axis the series of data belongs to, i.e. average viewers are on the left scale or on the right scale ?

Since scales on the left and on the right are different, an easy fix to the problem one would assume is to make those scales equal.


Chart from TwitchTracker : equal scales does not really improve the situation

But this does not improve the situation since we have had to change the scale which means either stretch the graph or downsize it. We may lose visual significance doing so.

So the solution is quite simple. Just color the axis labels with the same color than graphs.


Chart from TwitchTracker : finally something that can be understood at first sight

Tous les trimestres environ, Instagram sort une fonctionnalité qui change la façon d'utiliser ce réseau social. Il y a encore deux ans, avec un smartphone, utiliser Instagram était très contraignant, on ne s'en rendait pas forcément compte, mais en version PC, c'était beaucoup plus libre d'utilisation. Aujourd'hui la version PC a rejoint la version la plus coercitive. Déjà ça pue.

J'apprends aujourd'hui que Instagram a (ou va) sortir un sous-titrage automatique des vidéos courtes que les gens mettent en ligne sur ce réseau. En principe, c'est très bien. Sur le plan technologique, c'est un progrès car ça permet par exemple à des sourds d'extraire un texte d'une vidéo. Ca permet de récupérer un texte puis de le faire traduire dans une autre langue, ce qui permet indirectement de suivre une vidéo en langue étrangère.

Mais dans le monde dans lequel nous vivons, où faut-il le rappeler, Instagram est une filiale de Facebook, cet horrible monstre qui cherche à monétiser votre profil en ligne, en gros ce que vous lisez, quand, comment, etc. c'est une autre histoire. En fait, on peut tout à fait dire que cet outil automatique de sous-titrage permet de faire rentrer les vidéos dans le champ des objets dont le contenu est indexable et requêtable, bref un outil policier.

Autrement dit, si vous pensiez, par la vidéo, échapper aux contraintes un peu folles de notre société, et en particulier à des minorités actives qui traquent le moindre propos déviant de l'idéologie ambiante, vous vous trompez. Il faudra peut-être penser à héberger vos vidéos sur des sites russes ou chinois, où vous risquez d'être un peu plus tranquille...

Une fois de plus, la Russie montre la voie. On apprend :

extrait : "Russia said on Wednesday it was slowing down the speed of Twitter in retaliation for its alleged failure to remove banned content, and threatened a total block if the U.S. platform did not comply with its deletion demands."

Que l'état Russe intervienne sur la capacité d'une entreprise à servir ses utilisateurs, évidemment je suis contre, par principe. Mais rien ne prouve aujourd'hui que Twitter soit un service public, par le fait qu'elle censure tout ce qui sort de l'idéologie progressiste de son PDG. Et à ce moment là, instantanément, Twitter n'est plus une plateforme de communication libre, ce n'est plus qu'une plateforme de propagande. Parfaitement attaquable dans la plupart des démocraties du monde pour leur particpation dans son rôle "d'éditeur" qui interfère dans la communication entre les utilisateurs. Twitter ne peut pas se cacher en disant qu'ils ne sont qu'un tuyau. Ils pourraient l'être, mais ont décidé que non.

Freiner ou bloquer Twitter n'est que du fair play. Refuser par principe de bloquer ou freiner un outil de propagande de masse est irresponsable : et c'est ce qui se passe dans nos démocraties actuellement. La Russie sauve l'honneur de ce point de vue.

Plutôt que d'acheter aux enchères le premier tweet, les gens perspicaces et qui réfléchissent feraient mieux de parier sur la fin de twitter. Car elle est proche. Ce service était vulgaire d'emblée, mais aujourd'hui il est devenu dangereux pour la santé de ceux qui l'utilisent. Au même titre que la nicotine, utiliser twitter est dangereux pour la santé. La meilleure chose qui puisse vous arriver c'est de perdre votre mot de passe et de ne plus pouvoir vous connecter. A bon entendeur...

extrait : "The next on-premises/hybrid version of Windows Server, called Windows Server 2022, is now available in preview. It introduces advanced multilayer security, hybrid capabilities with Azure, and a flexible application platform, Microsoft says, and “secured-core capabilities” based on Windows Defender System Guard and virtualization security models to minimize the risk from firmware vulnerabilities and new forms of malware."

Year after year, I wonder if behind this security push is hidden the fact that this is now virtually impossible for an ISV to get their products downloaded and installed from the web. I mean aside Microsoft business partners, who probably get a pass.

You can believe this is a free market. It isn't. If you're an ISV shipping software for Windows, the most used PC OS on earth, Microsoft is putting you out of business by not letting you in in the first place.
Actually, it's not just Microsoft that is blocking you. Before you can even install software, it's quite possible actually that Google Chrome, the most used web browser right now out there, may block it for some reason, either because "it's not known enough" (I kid you not), or because whatever arbitrary rules it has in place after each and every release (the cadence of release is now increased to one every 4 months). Saying I don't use Chrome so I don't care is not valid, because your customers do use Chrome. And if they use Microsoft's default web browser, Edge, it's now based on Chrome. So you are screwed regardless.

If you think that stops here, you are being innocent. Of course if you ship software, at some point, you sell it, so you need a payment system. Turns out that payment systems are being more coerced these days, adding rules and breaking things apart every year or so. At some point, those changes made it impossible for me to both sell new software and get money for existing sales. Those problems have been solved last year, but to make it perfectly clear, I expect more coercion more road blocks at any time, and no way out. To say that this is not a stable environment to begin with is an understatement.

If you think this isn't enough, you are being delusional. It gets even worse. Your software is download from your website. Your website is hosted by a web hosting company, right ? Now why wouldn't you expect this hosting company to put road blocks every now and then in the name of security (i.e. bullshit most of the time), or else. Let's only take this example of SSL certificates made invalid over night and forcing you and your customers to use whatever SSL protocol the hosting company chose, like TLS 1.3 or even TLS 2.0, and by doing so making it impossible for a customer using a 5-year old PC to even connect to your website? There are many ways to screw you : force a PHP upgrade and it breaks your website overnight ; force OpenSSL off and connections do not work anymore, not even your emails ; make you responsible for email spams even though you are in the receiving end ; force you to rewrite MySQL code ; ... the list is endless.



And if you say it's not a problem because there are at least as many customers outside in the mobile world, putting aside that these are not the same customers, you are screwed as well because Apple and Google have a say in what you are trying to ship, in addition to hundreds of coercion rules from app stores.

All that means is that if you're an ISV these days, you are actually better off just giving up and becoming a plumber.

Chrome blog :

extrait : "For more than a decade, Chrome has shipped a new milestone every 6 weeks, delivering security, stability, speed and simplicity to our users and the web. As we have improved our testing and release processes for Chrome, and deployed bi-weekly security updates to improve our patch gap, it became clear that we could shorten our release cycle and deliver new features more quickly. Because of this, we are excited to announce that Chrome is planning to move to releasing a new milestone every 4 weeks, starting with Chrome 94 in Q3 of 2021."

Une livraison publique tous les mois, c'est la garantie d'être sans arrêt emmerdé par des mises à jour et à cette occasion des choses qui ne marchent plus par rapport à la version précédente, que l'on soit utilisateur, développeur ou webmaster. Si on m'avait dit dans les années 80 que l'informatique ça deviendrait ça, je pense que j'aurais laissé tomber tout de suite car ça n'en valait pas la peine. Pour moi, l'informatique ce sont des produits stables dans le temps. L'instabilité vue comme un progrès, c'est fort de café !

xlsgen 4.9.0.4 adds a new property to the xlsgen object model, to be used before loading files. This Style optimisation property allows to disable the style optimisation algorithm done by xlsgen on behalf of the client application, trying to remove useless styles. This algorithm is on by default and has been going on for years, it is nothing new. By setting this property as false, the algorithm is disabled, in order to meet scenarios where style optimization is not expected to occur (i.e. pure template scenarios).

engine.Workbooks.StyleOptimisation = False

engine.Open("mytemplatefile.xlsx", "")

...

Build 4.9.0.3 of xlsgen adds direct support for elapsed time, i.e. time used with either hour, minute or second enclosed in square brackets, as in [hh]:mm:ss in order to display out of boundaries numbers.

Using elapsed time, you can display with 30:00:00 the fact that you've had an event lasting 30 hours, notably bypassing the implicit limit of 24 hours. All it takes is to pass 30:00:00 as a date and apply a number format of the form [h]:mm:ss.

It works like this :

worksheet->Cell[2][1]->HtmlDate = L"<div format=\"[h]:mm:ss\">30:00:00</div>";

In Excel this is effectively stored as an elapsed duration of 30 hours, not a display artefact. Which means that formulas that depend on it can do their calculations properly.


Square brackets can apply to minutes or seconds as well, to represent an arbitrary duration in minutes or seconds.

This feature has been in Excel just about forever, but it was not added to xlsgen until now.

Build 4.9.0.2 of xlsgen removes half a dozen memory leaks, in all parts of the library. This makes sustained scenarios better work.

Another option we are introducing for the Search tool is one that lets you decide, upon a Search folder, whether a given file is supposed to be searched for depending on its size. That is, depending on whether the file is more than X mega-bytes and/or less than Y mega-bytes in size, it is included in the search process.
For instance, this option ensures extremely large files are not searched for. Or a large number of very small files where you know in advance it is no use doing a search in them.

The search tool has a new option available from the Options dialog. It is for including or not including sub-folders.

By default, and before that, the search tool does search inside all subfolders if a "Search folder" is initiated.

Depending on the folder organisation, this option may be welcome.