cracauer

I wonder how much of this doesn't actually have to do with the home, but rather office conditions:

- open seating and/or highly sound-reflective surfaces

- unfixable A/C and/or drafts and/or allergens

- all methods of transportation to the place where the office is are unsupported (e.g. Cambridge, MA)

- jerks cruising the office

- unwanted attention not or only pretentiously connected to work

There is no specific difference between compile-time and run-time (regular) computing when it comes to testing and documenting it.

As for learning something new, perl6 is a new language, this construct isn't in perl5, so they are in for a learning. In Lisp no language modification was required to enable this functionality in the first place, and so you do not have to learn any new language or language construct.

Yes, you have to learn the library that you or somebody else writes to enable this "enter the data in the safest way possible". But that is learning a library, not a new language, or language evolution.

It goes back to object-oriented programming. How badly did they hack up C compilers to implement either C++ or Objective-C? In Lisp the OO system used to this day was implemented as a compile-time library. A library still used today, too.

You don't have to wait for anybody to hack up the compiler, and test it, and document it, when compile-time computing is part of the language in the first place.

ETA: Another thing you can do with compile-time computing, without waiting for somebody to hack up the compiler: https://medium.com/@MartinCracauer/static-type-checking-in-t...

The article reasons that you should use the syntax that makes it safest to enter and later change that table you need.

Of course if you'd use Lisp in the first place you could make a new syntax to input those things in the visually safest manner without waiting for a language revision.

Compile-time computing is precisely about this, e.g. https://medium.com/@MartinCracauer/a-gentle-introduction-to-...

The situation follows the "mobile" (cellphone, tablet) situation where Chrome was just not providing an extension API that could be used to implement adblockers (or much else for that matter, e.g. Cookienukers).

This is no surprise at all. Competitive pressure for "desktop" (non-crippled computers incl. Laptops) required providing suitable extension APIs, but the writing was on the wall for a long time.

Some powerful people inside Google consider it theft to browse the web while blocking ads.

I'm not sure what the status of publishing and disclosure is in Chrome right now. A few years back the location via Wifi was a feature of the binary builds only (like DRM) and wasn't in open source Chromium.

Using wifi networks around a device is Google's standard, low-power way to determine a device's location. In a cellphone it is used so that you don't have to fire up the power-hungry GPS chip.

Since they built the entire infrastructure and database of wifi access points and locations (by scanning from the streetview vehicles and syncing with GPS) they also use it for the desktop browsers.

Which if you legitimately need the location of a "desktop" (which here includes Laptops) would be a nice way to go. It's just a bit of an unclear situation with regards to consent, especially informed consent.

(this is not to be confused with Chrome's private API chrome.networkingPrivate, which is used by the device owner to be able to pick and configure wifi networks without leaving Chrome)

strings /opt/google/chrome/chrome | grep -i wifi | grep -i loca

../../services/device/geolocation/wifi_data_provider_linux.cc ../../services/device/geolocation/wifi_data_provider.cc ../../services/device/geolocation/wifi_data_provider_common.cc

The other large binary blob in the non-opensource builds, apart from DRM, is the wifi network detection module.

It will look at what wifi networks are close to you, and Google finds out your physical location that way without your computer having a GPS chip or a cellphone network chip (Google has the full database of the center of gravity for every wifi network from the streetview cars, so the information of which network is how strong for your computer allows location by something like +- 10 meters).

Always surprised how few people realize this. Yes, on a random OS with no binary builds by Google I can have the Chromium browser. It does not have the ability to watch Netflix, though. To get that you need to run a Linux binary chrome in a Linux API translator.

I always thought that a ring singularity, which is a rotating disk of infinite density with no size in the 3rd dimension, would be excellent for cutting bread.

The carriers and OTAs are still using QPX the same way after the Google takeover. That was actually part of the agreement to let Google buy ITA.

It is still Common Lisp. Among other things you can tell by their contributions to open source Lisp projects.

Well, most of the big airlines pay ITA software for their Lisp written QPX engine so that it searches their insane pricing data structure to display on that airline's own website.

Sending SIGINT to all processes isn't what is needed here. It needs to go to the "processes" that are currently going on. With systemd's parallel execution that can still be narrowed down in a useful way, especially is some tail of some hanging command is running alone by now.

Obviously what the BSDs are doing, sending SIGQUIT to just the currently blocking-the-shutdown processes, is far superior. Now the coredumps are floating around the filesystem and they'll be there after reboot, and you can see who did what and was hanging in what backtrace.

There might be some way in which I had run a system that caused those endless slowdowns.

But the point is, and that's why I think systemd is garbage, that there is nothing there that helps me debug what is going on. If the shutdown is hanging there is nothing to do except the reset button or waiting for an eventual reboot. In neither case will there be any forensics about what exactly systemd had tried to do and how it thought that it failed.

That is the part that is not acceptable.

P.S. I shouldn't have to manually adjust a timeout on disabling swapspace on shutdown to prevent a need for a reboot by reset button. The kind of thinking that got big timeouts into those things is precisely why I say that systemd people just think differently than I do.

[nm]

[nm]

I have way too many cases of systemd startup items hanging with their timeout for no good reason.

Worse, my most complicated high-uptime machine usually does not shut down in a reasonable time. Systemd says "waiting for session user cracauer" (something like it) for whatever reason. It also hung on undoing swapspace, when that swapspace was a custom stack of block layers. I don't need swapspace to be "shut down". It went into 20 minutes something always stating another timeout when one expired. I mean, WTF?

The problem here is that I had to do an unclean shutdown on that machine (reset button) multiple times, and that I really can't have.

This also illustrates a point I have been making about Linux and the BSDs from day one: When the BSDs boot or shut down the keyboard is connected to the rc scripts. You can do Control-C for SIGINT and Control-\ for SIGQUIT, The latter makes everybody in the stack leave a coredump on disk.

Now, compare these two:

1) in BSD when there is a startup or shutdown item taking too long or hanging I can abort that single item and I can later debug what was going on with the coredumps.

2) on a Linux system with systemd I cannot "cut through" startup or shutdown items I don't want to wait for, and there is no way to debug any of that if the machine doesn't actually come up completely, or if thing happen at shutdown. The only interaction I can conduct is the reset button.

To add insult to injury, systemd also hides a lot of error messages that would traditionally be dumped on the console, and instead of giving me that error message systemd captures it and print on the screen instructions how to get that error message (which usually are longer than the error message was, WTF?). Instructions that I cannot follow because somebody detached my keyboard, and because I will never be in that machine in an up state while that context is available.

This also invalidates the point that systemd could be one platform that you learn once and then use on a wide basis. The debugging abilities are nowhere close to adequate, so you have to learn by try-n-error.

In my mind there is one killer feature in Lisp, and that is Compile-Time-Computing.

You have a macro system that isn't some lameass additional language with severe limitations like the C preprocessor or C++ templates. You have all the language available both at compile time and at run time. You can even use functions you already have (and tested) in both places.

This allows you to leave every single assumption you make during programming in one place. You don't have to splatter uncertainty about what the program is supposed to do into multiple places because you language isn't expressive enough, e.g. you cannot just redefine control structures to express an assumption. That is what leads to "changeable software", not just "readable software".

My writings on the subject: https://medium.com/@MartinCracauer/a-gentle-introduction-to-...

https://medium.com/@MartinCracauer/a-gentle-introduction-to-...

Example - using scientific units attached to literals in source code, but keep them at compile time and don't slow down runtime with unit checking: https://medium.com/@MartinCracauer/a-gentle-introduction-to-...

And speaking about early or late (static/dynamic) type checking. If you have compile-time computing you don't have to choose. How silly would it be to make a programming language that can only do one or the other. https://medium.com/@MartinCracauer/static-type-checking-in-t...

Finally, there is turnaround time during development: https://hackernoon.com/software-development-at-1-hz-5530bb58...

That is about the opposite of what works for me. A total absence of other signals isn't good. What I need is an "attention sponge". When attention lifts for a moment from the actual work, the "attention sponge" will hold it for a while, but that sponge is specifically chosen to not hold on to it.

An example is a background where a TV series runs that I watched 9 times already, let's say Babylon 5. The work computer has an attention accident (maybe just slow or whatever). My attention lifts from work, and B5 catches it before it goes off who knows where. Since B5 is not interactive and since I've seen it 9 times already it easily releases the attention so that it can go back to work.

I wrote more here: https://medium.com/@MartinCracauer/on-attention-focus-and-au...

When I bought one they were just straight Sagers, not even rebranded. No customization that I could see. At the time some important features were not supported including Linux' own suspend-to-disk.

Keyboard was so terrible and wifi dropped out in so annoying ways that I end up smashing mine (I reused the CPU and other components in a barebones later). This was 2013, though.

For starters, I want absolute numbers, which aren't in the web summary, but I can't download the PDF of the study.

No threads. no deal. There are also concerns about the ability to unwind the stack for non-local exits in manners that satisfy some languages' specification.

Our compiler is ready to target WebAssembly, but we can't run anything useful on it without those two.

What I want is some of those lenses and put them on my Canon. Looks like "pretty good" pieces of glass.

It's not just companies driving to more productivity.

For example, those open office layout are about putting more people per square foot. No matter what they say otherwise. Nobody "communicates" in an open office layout and they know it.

This is an example where per-employee productivity is sacrificed for other goals (getting more people into one building). And it is directly affecting stress and burnout.

Disclaimer: my own link.

This is part of a series about compile-time computing. There's elements of fast run-testing turnaround in there, too.

At the time I wasn't happy with that change. All of the BSD's did shared libraries with a.out just fine. The BSDs used GNU binutils, so the improvements were there to use for Linux. Linux' change away from a.out meant that binutils stopped developing a.out support, which then forced an ELF change on the BSDs.

At the time I could run an entire firewall on a 1.44 MB floppy, kernel, libs and enough userland for ipfw scripting. With FreeBSD 2.x. FreeBSD 3.x with ELF put that right out of reach.

Of course now that I spend my days parking silly stuff in random ELF sections I am pretty happy.

Here is more info: http://www.ai.mit.edu/courses/6.034f/psets/ps1/airtravel.pdf

It's from 2003, thing got a lot worse since then. The carriers make the rule mechanisms without having mathematicians or computer scientists at hand that watch the combinatorics. They have enough trouble not misfiling fares altogether (aka $0.02 fare NYC->London next Friday).

Oh and the carriers all insist on using a specific currency conversion table for the day. We had a whole bunch of them. Nobody really defines currency rates. And there are a lot of them.

I already mentioned several hundred of timezones. IIRC all carriers were happy with the same timezone file, amazingly. I think that was because ITA was the first to do one that comprehensively?

And that's just the fares. We didn't talk yet about seat availability.

You have to ask for seat availability for the complete fare-component, the thing that a fare covers. So if you go Boston-Copenhagen-Hamburg you don't just do seat queries for Bos->CPH and CPH->BOS, you are required to ask those questions in a context that says you travel BOS->HAM.

The seat availability for the same seats on the same flights on the BOS->CPH leg is different depending on whether you ask in a BOS->CPH context or a BOS->HAM context.

You can see how asking all those seat availability queries for all the different ways to fly in the query explodes nicely. Combinatorics at work.