ts4z

I don't think so. The cabinets were silk screened, but the control panels and marquees were different. The marquees, in particular, are large vinyl stickers that cover glass. Control panels were generally not silk-screened, either.

Volume was roughly similar (thousands to low tens of thousands of cabinets).

Things differed from game to game over time. My Missile Command had a silkscreened control panel, but I think they went to overlays which were more durable and could be replaced.

Hear hear. I guess we still have Anchor.

C++ would be bonkers even if Rust did not exist.

This is a specialization of the general statement that C++ is bonkers.

Go has good (enough) built-in arrays and maps. But if you want a tree, without generics, you're really limited. With generics, you can get a nice containerized type, but you don't get the nicer syntax that the builtins have.

It's not just types, either. Look at the signature for the built-in sort, which is amazingly cumbersome to use. A generic wrapper around it hides all the ugly.

Unfortunately, that isn't true.

https://www.wired.com/2012/07/leap-second-glitch-explained/ https://developers.google.com/time/smear

Halted was an electronics surplus store. A really good one. They had old tubes, old ICs, stuff left over from Atari. They had aisles of capacitors, some with date codes in the mid '80s, and newer surface mount stuff. They had a whole wall of 1/4 W resistors at two cents a piece. They had all kinds of random parts for keeping old electronics running, and making new stuff. And they had a receipt for an oscilloscope they sold in the '60s to some kid in Palo Alto named Steve Jobs.

Unfortunately, the owner retired and sold it off for parts.

Seems like it should work for arbitrary byte strings (any charset, any encoding)but obviously the performance characteristics will differ because of non-uniform distribution. But that happens even in ASCII.

SASL came out as a generalization of the IMAP AUTHENTICATE mechanism. CMU wanted Kerberos to work and it had been done as something of a one-off in telnet, and initially in IMAP. There were a couple companion protocols proposed for IMAP (stuff like contacts) that the same group was working on, and they wanted to leverage the same mechanism. From there, might as well do the same thing for POP and SMTP, etc. So they started working on a library (which Cyrus IMAP didn’t use for at least a while, sorry my fault).

Kind of funny that SASL is the most durable piece of the effort.

(I doubt this is entirely accurate. I wasn’t there for a lot of it.)

This is very gratifying to read. I had a lot to do with the original spec, and I'm glad you find it useful.

FWIW they were not Berkley DBs. IIRC the only db was the duplicate suppression feature.

Folders (mailboxes in proper IMAP lingo) had hand-built indexes. Good stuff. Credit to jgm, the original author.

DI at LinkedIn was used for development, for unit test isolation, and to reduce tight coupling.

One big problem with a giant "Application" class is that it means all of the dependencies are laid out there, and their dependencies, and their dependencies, all named and instantiated. But some dependencies are in libraries, and basic detail encapsulation means ... a factory.

Offspring wasn't much of a framework, more of a set of conventions and utilities for building that stuff in plain Java code (with key annotations). In particular, I think the Offspring setup wasn't opinionated about the framework of the rest of the application, although other parts of LinkedIn were (and presumably still are).

I overlapped at LinkedIn at the same time as the author. While there, I wrote my first (and to date only) FactoryFactory.

LinkedIn replaced its uses of Spring with a thing called Offspring. Offspring explicitly disavowed being a dependency injection framework, but it did a similar job for us. I rather liked it. Notably, you just wrote Java with it. Invariably, in Offspring, you'd have to write a FooFactory to construct your Foo object to inject it into some (other class. By convention, all of the factories ended in Factory.

Well, I had a use case for a runtime class that needed to make a per-request factory to make little objects. So to make my Bars, I needed a BarFactory; and to construct the BarFactory, I needed an Offspring factory, thus BarFactoryFactory. There it was. I felt a little weird after that.

I suspect the EventFactoryFactoryFactory code here was such an Offspring factory being used for dependency injection, but I can't explain why it produced a FactoryFactory.

An hourly rate was tried and it was a pain in the ass for staff and now it’s gone. (Source: I am an irregular volunteer technician, and have been going there as a customer for 15 years.)

I’m an occasional volunteer. Sometimes I show up and fix games (although it’s been a a long time since I’ve done it). Machine rotation is an issue. They do change them out but it is always trading out somebody’s favorite for somebody else’s favorite.

Weak flippers are probably not the result of weak coils, but of wear of flipper mechanisms. A complete flipper rebuild is hard to do on a budget. Some games (and BK is one of them) have flippers that haven’t worn well. (I think BK might still have 25V flippers, for instance.) But next time I’m there I will make sure to look. It’s important to be able to kick the ball upstairs on Black Knight.

I will say noise is always a problem, but the museum isn’t always crowded. I’ve been going a long time, and it’s been ten years since I could go early in the afternoon, but it is worth a shot.

Thanks for playing. Do mention any issues to the front desk. They will get attention, albeit triaged, and fixed on a budget.

It has not. The games just get a lot of play. (I occasionally volunteer to fix them.)

I just want to tell you both good luck. We're all counting on you.

(As noted elsewhere it's nanoseconds.)

time.Second*1 gets the same value; it's not overloaded. Well, ok, so what actually happens is that time.Second is a time.Duration, and Duration*int yields Duration (and int*Duration yields Duration).

But the value of time.Second is actually a Duration with value 1000000, IIRC -- it's microseconds. It's just the type that's special, and the int handling here is general over a lot of types.

It really is nice in practice.

You need a domain name if you want to own your destiny. You certainly need one for a company if (a) you ever might want to change service providers, or (b) your service provider might one day go down, out of business, or just plain screw up.

Depending on Google for accessing your site is putting the cart before the horse.

Do you need a great domain name? Maybe not. 1998 was great for people overpaying for domain names. But books.com turned out not to be that important. Or toys.com. Or pets.com. On the other hand, you won't learn much about rainforests at Amazon.com, but you can buy books, toys, and cat litter there.

Glad to see this is available. I bought it back when. It was worth the money.

I agree with this. The limited location I find that I really miss ternary operations is initialization.

  v := if foo() {
    7
  } else {
    11
  }

But this means {} blocks now have values, which is weird in a C derivative. Of course, one could do

  v := func() int {
    if foo() {
      return 7
    } else {
      return 11
    }
  }()

but... that's kind of awful.

And did they handle surrogate pairs correctly?

My team managed a system that did a read from user data, doing input validation. One day we got a smart quote character that happened to be > U+10000. But because the data validation happened in chunks, we only got half of it. Which was an invalid character, so input validation failed.

In UTF-8, partial characters happen so often, they're likely to get tested. In UTF-16, they are more rarely seen, so things work until someone pastes in emoji and then it falls apart.

I know you're kidding, but I want to note that UTF-256 isn't enough. There's an Arabic ligature that decomposes into 20 codepoints. That was already in Unicode 20 years ago. You can probably do something even crazier with the family emoji. These make "single characters" that do not have precomposed forms.

Depends on the company. Dilution is normal, but some companies are buying back stock to use up excess cash; in this case, they can issue those shares to employees.

ps RSS measurement is pretty good for a start (although note in a forked process, shared copy-on-write pages are both reported as RSS for both the parent and child process).

top reports this as RES.

IIRC, debugging information is in a separate part of the process, so it's not loaded until it's used. Does that make it free? Probably not quite, but the kernel can ignore it until the process (presumably via its debugger) looks at it.

I disagree, and have used LinkedIn to keep up with a lot of former coworkers. (But I used to work at LinkedIn, so I clearly have a bias.)

Enjoy the break. They'll be back.

There are various features on the search functions on LinkedIn, and most recruiters know that nobody quits the job they just started.

I'm curious -- is it the binary size that's a problem, or the resident size in memory? Demand paging should help, although you'd be stuck with carrying the enlarged binary.

Let me cheat a bit and say Unicode comes in three flavors: UTF-8, UCS-2 aka UTF-16, and UTF-32. UTF-8 is byte-oriented, UTF-16 is double-byte oriented, and UTF-32 nobody uses because you waste half the word almost all of the time.

You can't reduce the bytes in UTF-8 or UTF-16, because you'll scramble the encoding. But you could parsing the string, codepoint-at-a-time, handling the specifics of UTF-8, or UTF-16 with its surrogate pairs, and reversing those. This sounds equivalent to reversing UTF-32, and I believe is what the original poster was imagining.

Except you can't do that, because Unicode has composing characters. Now, I'm American and too stupid to type anything other than ASCII, but I know about n+~ = ñ. If you have the pre-composed version of ñ, you can reverse the codepoint (it's one codepoint). If you don't have it, and you have n+dead ~, you can't reverse it, or in the word "año" you might put the ~ on the "o". (Even crazier things happen when you get to the ligatures in Arabic; IIRC one of those is about 20 codepoints.)

So we can't just reverse codepoints, even ancient versions of Unicode. Other posters have talked about the even more exotic stuff like Emoji + skin tone. It's necessary to be very careful.

Now, the old fart in me says that ASCII never had this problem. But the old fart in me knows about CRLF in text protocols, and that's never LFCR; and that if you want to make a ñ in ASCII you must send n ^H ~. I guess you can reverse that, but if you want to do more exotic things it becomes less obvious.

(IIRC UCS-2 is the deadname, now we call it UTF-16 to remind us to always handle surrogate pairs correctly, which we don't.)

TLDR: Strings are hard.