jhallenworld

Do you really need a TPM if you have something like ARM TrustZone?

>V8 emits a near-jump for all forward jumps. If the target ends up too far away, the near-jump target is adjusted to a jump pool entry that contains a long-jump to the actual target

This sounds weird to me... Why not assume that all jumps need to be long to start with (so that the code is valid), then relax them to short jumps during an N-pass optimization stage- so that you get the smallest possible code?

They only want the screen for the stereo and backup camera, not anything else. It's easier to update a car from 2004 say to have Android Auto than to fix one made in 2024 that doesn't have it. $400 aftermarket stereo from crutchfield..

I would say that 2005 was peak car, except 2000 is slightly better because they had not yet gone nuts with serialized components.

(another reason is that direct inject fuel injection hadn't taken over yet, it's a disaster)

Imagine a world where you can click on references in your paper and have them immediately come up, like the rest of the web. This can be done today:

Always provide a DOI-style link, for example: https://doi.org/10.1088/0029-5515/30/2/001

These can be easily changed to actual working links with a simple browser substitution rule: replace the "doi.org" with "sci-hub.se" or whatever.

I'm not blaming you. By providing links, your citations go beyond what is required for academic papers.

Would it be rude to print the link "https://doi.org/10.1016/0005-1098(83)90046-8" but actually link to https://sci-hub.se/10.1016/0005-1098(83)90046-8 when you click it? :-)

The DOI is key, then you can use a browser extension to do it, for example: https://github.com/natir/Redirector_doi_sci-hub

Come on IEEE...

So this link is interesting for a different reason: look at the references at the end of the paper. It's awesome that the references include URLs. IMHO, old papers should all be updated to include such hyperlinks.

I'm pleased that the references to other ACM papers do work.

But try to click on this one:

Bainbridge, L. 1983. Ironies of automation. Automatica 19(6): 775-779;

https://pdfs.semanticscholar.org/0713/bb9d9b138e4e0a15406006...

Fail! No way to read the paper without paying or pirating by using scihub (and even if you do get the .pdf via scihub, its references are not hyperlinks). This does not help humanity, it makes us look like morons. FFS, even the music industry was able to figure this out.

I've used it on a tiny microcontroller because libc's quicksort was huge.

I think the driving force behind the look of the recent mainframes is from IBM's Italian designer, Camillo Sassano:

https://www.idsa.org/profile/sassano/

Well there's a whole group, but Camillo is the guy I worked with when I was there.

I'll say this about IBM: because it's so old, it was the most diverse company I ever worked for- including age, nationality, race, sex, and any other category you can think of. Basically you had all types of people in all stages of life, not just young white workaholic tech-bros. The founders are long gone, so everyone there (including CEO) is a professional- meaning nobody has any kind of personal attachment to the company. We were all in the same boat, as it were. When your older coworker suddenly disappears due to a stroke, it puts things in perspective.

The fast-paced startup is really the hack, combining the energy of youth with the ego-mania of their founders. Ask yourself, is it healthy?

Anyway, IBM's customers tend to be other fortune 100s and governments- basically other similar organizations, and my experience was that we took care of them pretty well. The products were not pretty (no Steve Jobs-like person to enforce beauty), and rather complex due to all the enterprise requirements. But they were quite high quality, particularly the hardware.

That's awesome. Before ~2007 they allowed you to use open-source Pidgin to connect to the Domino servers. A friend of mine and I used it to make a bot: if you sametimed me, you got Zork.

It reminds me of another IBM IT rule: they wanted your chat history (and email) older than two years to be all deleted for legal liability reasons. It was important to save your sametime chat history (an XML file) and export your email periodically if you wanted to keep this stuff.

This was actually better than Slack in one way- you could grep the files for things, and not have to rely on search within the tool.

Probably, but now it's going to be formalized and will entail a lot of paperwork (manual entry on many very badly written JAVA-based CRUD applications). Sure, these things are all good ideas, but trust me, they have all been overthought. Do you want this to be your job?

>mind boggling Byzantine rules

Hint: by all means possible, make sure you are not the owner of (or manager of the person who owns) any assets beyond your personal laptop. If, for example, you end up being the owner of all the development and test servers of the original company, then it will become your responsibility to ensure that each OS (of each LPAR of each VM) is security compliant, is running the end-point asset manager, and has up to date OS patches, that the DASD is encrypted, and you must periodically show physical proof that the asset still exists and indicate where it's located- photos of assets tags or whatever. It will be your responsibility to dispose of the asset (with all associated paperwork) at the end of its life.

It helps if such machines are not actually on the 9. network, or are behind an internal firewall (then they don't care about the security compliance as much).

You can measure it by how many management steps you, as an employee of the recently acquired company are from the CEO in the hierarchy. As time goes on, this number tends to increase. It used to be easy to see this in Lotus Sametime or something that had some form of employee directory.

Yes, it is... (negative differential resistance to be more precise)

https://en.wikipedia.org/wiki/Pearson%E2%80%93Anson_effect

https://en.wikipedia.org/wiki/Negative_resistance

Easy negative resistance oscillator: a neon bulb in parallel with a capacitor connected to a DC power supply through a resistor.

I always assumed ultra-processed means that the food is loaded with preservatives like phosphates or BHT. I guess that's part of it, but maybe the efficiency of digestion should be considered. I remember Ben Krasnow (Applied Science) measured the calories in poop, humans are not very efficient at extracting all calories leading to very likely large efficiency variance between foods. But extending this further, the calories lost during preparation should be accounted for...

So how about: calories * digestion-efficiency - calories you personally need to expend to prepare or acquire it. The higher this number, the more processed is the food. So cane sugar is very bad, unless you personally harvested it.

Bad news for highly paid programmers.. basically all food should be considered ultra-processed since no physical labor was needed to acquire it.

I did the same, but with Tandy 4000s.

>That's when I knew Arm would eventually eat x86: in 1989. It's finally happening now.

I had kind of the reverse feeling: when the 486 came out, I knew those expensive SPARC and MIPS workstations were all doomed.

In the early years of Linux, before it had networking, we used KA9Q for the TCP/IP stack:

https://www.ka9q.net/code/ka9qnos/

This worked in DOS, but was easily ported to Linux.

As far as DPMI: I used the CWSDPMI client fairly recently because it allows a 32-bit program to work in both DOS and Windows (it auto-disables its own DPMI functions when Windows detected).

https://en.wikipedia.org/wiki/CWSDPMI

The lack of (easy) recursion in CPP is so frustrating because it was always available in assembly languages with even very old and very simple macro assemblers- with the caveat that the recursion depth was often very limited, and no tail call elimination. For example, if you need to fill memory:

    ; Fill memory with backward sequence
    macro fill n
        word n
        if n != 0
            fill n - 1
        endif
    endm

    So "fill 3" expands to:
        word 3
        word 2
        word 1
        word 0

There is no way this was not known about when C was created. They must have been burned by recursive macro abuse and banned it (perhaps from m4 experience as others have said).

The other assembly language feature that I missed is the ability to switch sections. This is useful for building tables in a distributed fashion. Luckily you can do it with gcc.

The worm in shockwave rider released secret information to the public. Turns out a worm was not needed for this, just wikileaks.

WPI was immune, the main machines on the net at time were an Encore Multimax and a DEC-20.

I thing I learned only recently is that the write protect switch on the SD card is not an electrical switch connected to anything in the SD card itself: it just hits a lever in the SD socket that opens a contact closure and it's up to the system (hardware and software both) to bother to look at it. So on many systems the write protect switch doesn't even work.

Wish it was Verilog or SystemVerilog..

I've been getting tremendous use out of PicoRV32- it works, it's tiny, and for many use cases ("management plane") you just don't need much speed. I work around its slowness by providing things like relatively large communication buffers in the FPGA. I use it in "execute in place" mode from external SPI-flash (the FPGA's config flash), but with an instruction cache. It can do floating point via emulation which is handy for printf.

I've been meaning to update my toolbox to at least a pipelined processor of some sort (to up the IPC rate to at least 1), but so far just had no strong need. For applications that really need CPU power, I use SoC FPGAs like Zynq.

My son had an MRI with gadolinium- turns out he is allergic to it, he developed a full-body itchy rash. There were like 20 interns in to see him, for the experience I guess. They were ready to send him to the ER in case it interfered with his breathing, luckily it didn't.

Also I recommend Bob Morgan's book:

https://turbo51.com/download/Building-an-Optimizing-Compile-...

Try maxima, it's open source:

https://maxima.sourceforge.io/

I used it when it was called Macsyma running on TOPS-20 (and a PDP-10 / Decsystem-20).

Text interface will require a little learning, but not much.

They don't say that the currencies are pegged, but I'm pretty sure they're defacto pegged. Same deal with the Euro.

Or it gets built, but NextEra convinces the dear leader to tariff energy imports. Or Canada just cuts us off for being jerks.