Web dev in DC http://ross.karchner.com
944 stories

Surfing Upstream

1 Share

Today in Tedium: It’s often been suggested that the web browser is at real risk of becoming a monoculture, all thanks to the browser engine behind most of our clicks. Chromium and its forked-off predecessor WebKit are everywhere, defining the frame through which we access the internet. (Not helping is the fact that Firefox, the internet’s third rail, occasionally has a show-stopping problem, like the issue with HTTP/3 that made it briefly unusable last week.) The concerns about the market becoming driven by just one or two browsers is a key reason why the browser market appears to be evolving in a way probably not seen in quite some time; a lot of new browsers are in the works these days! Sure, there are some quite-good options that are fairly established at this point, like the power-user-focused Vivaldi, that appear to be focused on more specific niches, but the mainstream seems like something of a lost cause. So what makes someone want to reinvent the wheel and make a mainstream play on one of the most common things in all of tech? Well, I asked someone who’s working on a hot new browser. (Perhaps you’ve heard of it? It’s called Orion.) Today’s Tedium talks browsers, ad-tracking, and shifting paradigms. — Ernie @ Tedium

⬇️ Be sure to check out today’s sponsor, Revival, below. ⬇️


Ever try to buy a nice rug online? The process has traditonally been a bit of a pain, but in 2017, Revival stepped in to give floors the world over a makeover. With more than 4,000 rugs from 3 different countries—produced sustainably, with fair wages—you can tie the room together while keeping your ethical compass in check. Learn more, and check out a few cool-looking rugs, over this way.


The amount that Netscape charged for version 3.0 of its Navigator software, which at the time was competing against version 3.0 of Microsoft’s Internet Explorer, which was available for free. (It was, admittedly, something of a leaky-faucet business model, akin to shareware.) In a 1996 review in Fast Company, reviewer John R. Quain made the case that Netscape was a better deal despite the significant cost difference by saying this: “When did you hear of Bill Gates giving away for free something you’d want? Bottom line: cough up the $49 for Navigator.” Most people did not heed this advice, and within a few years, Netscape’s 80 percent market share was basically gone, in favor of a free (and dominant) Microsoft browser.

Internet In a Box

(Computer History Museum)

The crossroads between web browsers and monetization

I remember the days when you could walk into a Best Buy and you could buy a web browser off of a shelf. It was not a particularly heralded period in internet history, but it was a period that happened. One of the early versions of this idea, SPRY’s “Internet In a Box,” attempted to sell the idea of just making it simple to get online. Netscape tried to make the browser closer to a professional application suite.

But quickly, that changed, and the browser became a commodity that had to be paid for, somehow.

And in that light, it changed the experience significantly, because it changed the paradigm of control. In the early internet era, you generally had full control of this result. A terminal screen could be tweaked and prodded as needed to produce a desirable result.

But with the rise of the graphical web browser, we ended up ceding some of that control to (1) the people that made the browser and (2) the people that made the web page.

In some ways, users giving up a little of that control was good; it ensured, for example, that browser makers could continue to innovate and improve the underlying technologies of the internet, and that websites would be able to do things like, you know, brand and design themselves.

But it has never been a completely perfect trade-off, in part because of how we chose to pay for the thing in front of us. Pop-ups and adware made it a bad deal early on, and trackers have been a fact of life on the web for decades, with no sign that they’re going away anytime soon.

In many ways, once the other side of the connection got its claws into our usage habits, it kept taking. There was no motivation to get them to stop, after all—they had to monetize somehow, right?

(And recently, at least one big company went for the kill: Axel Springer, the German owners of Business Insider and Morning Brew, attempted to sue in their home country to prevent HTML code from being modified by the end user on copyright grounds, an end-run to stop ad blockers. Fortunately for the end user, they lost.)

With all that in mind, the concerns about monoculture taking things over make a lot of sense. If the motivations driving the browser you use are being led by monetization, that means the consumer is at risk of losing control over the experience.

Vladimir Prelovac

Vladimir Prelovac, the creator of the buzzed-about Orion Browser.

And that’s the point that Vladimir Prelovac, a longtime tech executive and serial startup founder, is really worried about.

“Currently every single mainstream browser out there is either directly or indirectly relying on either data or ads for monetization and this is bad both for the users and for the web,” he said in an email interview.

The onetime GoDaddy executive, who is perhaps best known for launching the WordPress management tool ManageWP, has been aiming a bit bigger with his most recent project—a combination of web browser and search engine that aims to right the focus of both technologies, and he’s taking aim at the hierarchy of advertising and tracking in the process, starting with the browser.

“I think that ad/data-based monetization of browsers as a business model had a good run, but it is time to reconsider,” he adds. “The implications of ad-supported technologies to user privacy, user experience and the web itself are simply too dire to be tolerated by humanity in the future.”

This is not an uncommon concern among browser-makers—just ask fans of Brave, for example—and when I talked to Vivaldi’s Jon von Tetzchner a year ago, he brought up similar concerns.

But in some ways, Prelovac wants to take this discussion further, by going back to the thing that Netscape tried to do more than a quarter century ago: Charge for the browser the old-fashioned way. The browser he’s building, called Orion Browser, aims to make money through a more direct funding model. As explained in the company’s FAQ:

Our Pro version will allow users to support Orion’s development. Will it generate revenue? That’s up to you. Regardless, all funding for Orion will come from its users rather than ads, tracking, data monetization or any other indirect way.

That this is an experimental thing to charge $5 a month or $50 a year for a web browser, as Orion (currently in an invite-only beta) will do. But it might be the foundation of a more normalized experience with an application many of us lean heavily upon.

“Obviously, in order for someone to voluntarily pay for a browser in a day and age where so many free alternatives are available, the browser itself has to be exceptional,” Prelovac said.


The number of web browsers that Prelovac, the primary developer of Orion Browser, has collected in his research of the browser market. All of them are Mac-based, as Orion is starting with MacOS. “Most people have usually heard of the top 4-5, maybe 10, but there is so much diversity and innovation happening in the browser market,” he said. “It is actually very exciting!”

Orion Browser

Yes, I used my own website in this screenshot. Let me have this.

Meet Orion, the power-user browser that even your Grandma could potentially love

With the first stab at Orion, one of the first things you’ll likely notice is how lightweight it is. In some ways, it comes across as a more efficient version of Safari, a browser that has seem some fairly controversial changes in recent months.

That is actually a major tell as to its roots—it’s a WebKit-based browser, which is actually a little refreshing, given how many browsers lean heavily on Chromium. Love or hate the move to bring everything into WebKit or Chromium, but the truth of the matter is, building a new web browser engine from scratch is difficult and time-consuming.

(One company, the embedded systems firm Ekloh, is attempting to do this right now with its clean-room browser Flow, and it’s taken them quite some time to do things that many browser users take for granted, like support Google Docs.)

Web Browsers

Some of the many web browsers Prelovac researched when building Orion.

In the case of Orion, though, it reflects an effort to emphasize performance and user flexibility over all else. At this time, Orion is arguably the most performant browser on the Mac, essentially getting all of the speed benefits you might see from using Apple’s native Safari as your primary browser, while not leaving out many of the things that ultimately lead many users to rely on Chrome instead. It’s the opposite of a RAM hog, and it could extend your battery life just a little bit further as a result.

Essentially, the result reflects all that research that Prelovac did into web browsers, which hit on some of the major cues I’ve found in my own web browsing. (And he’s definitely trying to better understand this market, too. When I mentioned to him, for example, that I was a big fan of the keyboard-centric “flow” that the low-resources web browser Min offers, he took the time to listen to why I found this flow useful.)

Plus, he knows his history—the Mac, famously, is the home of numerous browser experiments over the years, some of which hold substantial historic roles with the operating system.

“Orion is a fully native app, respecting the decades-old Mac heritage in design and implementation, as well as the great line of Mac browsers such as OmniWeb and Shiira,” Prelovac says.

One thing that Orion pledges to do that gives it a significant advantage over you garden-variety Safari, however, could make it an interesting alternative to those who find Safari’s limited access to browser extensions a turn-off. Simply put, it tries to support everything, including both modern Chrome and Firefox extensions.

The support for this potentially ground-breaking feature is a little spotty at this time, alas—for example, my favorite extension, Briskine, installs and works in both its Mozilla and Chrome Store variants, but cannot log in, meaning that I can’t access my stored data through the extension, limiting its value to me. But at the same time, this is something the browser actively warns you about, and as the browser matures, this will likely become less of an issue.

One standout feature that you’ll notice if you go into the Mac’s native full-screen mode is that the browser chrome (that is, the bar and tab interface) automatically hides itself, giving you a more immersive experience with your content. The only thing you see on the screen is the page itself. It’s minimalist, but a different kind of minimalist from some of the other browsers I’ve looked into over the years.

Orion Settings

Want to turn off web fonts? The option is right there. Not even The New York Times can stop you.

But it’s the small features that stand out. On the side of the browser bar, in a spot that Safari doesn’t really take advantage of itself, is a gearwheel signifying an options menu. That menu offers some fine-toothed controls that go beyond what Safari and many Chromium-based browsers do. You can enable reader mode, block tracking and turn off fonts—a useful feature that makes your webpages less pretty, but also removes a potential tracking vector (as many web fonts are distributed by Google) and an element that can slow down your browser speed.

Other browsers, like Vivaldi, also have these settings, but what’s nice in this case is that they’re organized in an easy-to-uncover spot. Orion doesn’t offer the kitchen sink; instead, it has a few extra features that many power users will enjoy and regular users will find a nice change of pace. (It even promotes the idea of this being a Grandma-friendly browser in its FAQ.) And given the business model approach, odds are that its financial motivations won’t stray too far from this basic approach.

While the final result looks like a native MacOS app, Prelovac says that in the long run, he hopes to bring this ground-up approach to other platforms, with the goal of building a browser ecosystem that offers an alternative to the seemingly Google-centric web we’re all living in.

“I have no doubt in my mind that if we manage to execute on the vision for Orion, it will be the greatest web browser that Mac has ever seen,” Prelovac says.

“Early on, we realized that our mission to achieve a more humane web would mean offering a holistic, alternative infrastructure to consume the web, not just one component of it.”

— Prelovac, discussing the ecosystem around the Orion browser, which will involve a search engine called Kagi Search, also currently in private beta, as well as an email client that will compete with Gmail. The idea: produce an alternative ecosystem to Google that can offer an alternative to the vertical and horizontal ecosystem it offers for users that isn’t clouded by monetization needs at every corner. Yes, he realizes this might prove a bit of a lift: “I am aware that this is a very ambitious undertaking, but I am afraid that there is no other way to approach the problem!”

The aspiration that Orion has—building a better take on Safari, with a focus on privacy and a shifted business paradigm—feels ambitious and somewhat modest at the same time. When asked what his goals are for this browser/search engine/email client empire he’s hoping to build, he aims for a double-digit browser share on the Mac, which (with a little luck) seems totally accessible given the crowd-pleasing nature of what’s already been built.

“Increased popularity of Orion would then hopefully produce enough Orion Pro users so we can pursue support for other OS platforms, emerging web standards and protocols, and niche browser features, while optimizing for speed, memory, and battery use and contributing to WebKit itself,” he said.

(A 2018 estimate of MacOS market share, given by Apple at a press conference, puts its active user base around 100 million; in that light, a double-digit market share, even if modest compared to Chrome and Safari, would be a major success story.)

In a lot of ways, Orion goes back to the leaky faucet approach of early Netscape—yes, you can download it for free, and yes, it will totally be usable in that form. But if you want pro features, here’s where you can sign up.

We have embraced this model with so many other things we do in our digital lives, from music to streaming to password managers to office suites. Why not web browsers? After all, they probably know more about you than any other application on your computer.

That’s the promise of Orion Browser. It’s nice to see someone’s trying it.


Thanks to Vladimir Prelovac for taking the time to chat for this one. Find this one an interesting read? Share it with a pal!

And thanks again to Revival for sponsoring.

Read the whole story
2 days ago
Share this story

Examining the covidtests.gov architecture

1 Share

A day early, the Biden Administration has quietly launched the new website that allows households to order four COVID-19 rapid antigen tests.

The reporting from last Friday, when details of the website were first made available, indicated the U.S. Digital Service (USDS) and the U.S. Postal Service (USPS) were involved, and that the site would use USPS’s existing web properties and facilities to process orders and deliver the tests.

Now that the site is live and accepting orders, let’s look at the outside indicators to see how it was constructed.

The landing page

The www. domain name is a CNAME record that ultimately resolves to Akamai. This isn’t surprising, as Akamai has performed as a CDN for U.S. government properties before.

Lookup of DNS information of www.covidtests.gov on command line.

The A record for the naked top-level covidtests.gov name are IP addresses in the Akamai network.

Lookup of DNS information of covidtests.gov and an IP address on command line.

So the landing page and its CSS and JS dependencies are likely objects in Akamai’s NetStorage product fronted by its CDN product.

The call to action button “Order Free At-Home Tests” takes the user to a USPS web property, https://special.usps.com/testkits, which is the actual order form.

The order page

This domain name resolves to AWS CloudFront, its CDN offering. The authority section of the NS record for special.usps.com is ns-418.awsdns-52.com, which indicates special.usps.com is managed by AWS’s Route53 DNS hosting product.

Lookup of DNS information of special.usps.com on command line.

The order page itself is an object in AWS S3 object store as an origin server, fronted by the CDN.

Lookup of HTTP header information about special.usps.com on command line.

Submitting the order form is an HTTP POST to yet another new domain, special-api.usps.com:

HTTP request/response details on special.usps.com in web browser dev tools.

This domain name appears to map to AWS API Gateway.

Lookup of DNS information of special-api.usps.com on command line.

The form POSTs a JSON blob to the API endpoint (just the root path in this case), and returns confirmation data to the user. That is the entirety of the order transaction.

async function confirmOrder( recipient: KitRecipient, sender: KitSender ): Promise<Response> { store.dispatch(setIsActionPending(true)); const backendHost = APIEndpoints().API_BASE; const body = { firstName: recipient.firstName, lastName: recipient.lastName, address1: recipient.address1, address2: recipient.address2, city: recipient.city, state: recipient.state, zip: recipient.zipCode, email: sender.email, uCode: recipient.uCode, }; const res = await fetch(`${backendHost}/`, { method: "POST", mode: "cors", headers: { "Content-Type": "application/json", "X-Api-Key": "V2FrZSB1cCwgTmVvLi4u", }, body: JSON.stringify(body), }); store.dispatch(setIsActionPending(false)); showError(res.status); return res; } 

This is the extent of what we can tell about the implementation and internals of the site from outside signals. I suspect what’s happening from here is that API Gateway is in front of a Lambda function (indeed, this is a common design pattern that AWS documents) that does minimal-to-no processing of the JSON blob and puts it in a database, likely DynamoDB given the overall managed services flavor of this implementation. At that point, backend processes can take over, likely kicking off notifications, enqueuing business tasks, and talking (via some peer/VPN) to the USPS enterprise network.

Building the frontend of government

What’s interesting about covidtests.gov is that, in spite of the reporting of the use of existing USPS web properties to aid in fulfillment, this appears to be a new custom implementation of the order form. It seems to bring together a set of AWS-managed services (again, speculating on the degree to which this is true all the way down into the stack) using largely statically-rendered content served from object stores and CDNs. There is a single point of transaction from the user’s perspective, the simple POST of a small amount of JSON data to the API endpoint.

This is a very common overall design in the modern web services stack; nothing out of the ordinary here. Indeed, the relative “boringness” of the architecture and seeking managed services from ISPs like AWS and Akamai, who are proven at the largest scales, was likely a desired aspect of this implementation.

I’m not aware if the USPS is typically a big cloud user. In fact, I would be surprised if they had this architecture laying around to be picked up by the Administration. It’s more likely that USDS and AWS worked together to use the USPS design language and backend integration points to achieve this relatively single-use, purpose-built site (Edit: A source tells me the USPS did in fact design and implement the cloud architecture of the site.). Contrast this approach with 2013 and the era of the HealthCare.gov launch when the state of the art in government was to administer servers in private data centers with numerous moving parts and failure modes without the resources and experience to handle intense public demand and traffic.

The rate at which the “frontend” of government (i.e., that with which the public primarily interacts) is moving to new digital services is increasing, and so are the public’s expectations for these services when they do appear. They expect them to be available, responsive, usable, on the devices they use, and for their interaction to fulfill their needs.

Simple, dependable architectures such as the one covidtests.gov seems to employ are proven at scale. This affords agencies the space to focus on improved user experience and service delivery, rather than consuming large resources keeping sites up and running. This takes operational experience and know-how, though; even with the use of managed services, composing a full, end-to-end digital service experience takes skill. It takes experience to identify the patterns of digital services that are best addressed by various system designs. But scalable web services are, in 2022, a commodity available to all. There is no excuse for getting this wrong. It’s heartening to see that the team seems to have gotten it right.

There is still no turnkey solution for UX, but success in government digital services lies in getting the fundamentals right, building public trust, and inspiring confidence from agency staff that they can meet extraordinary needs. Effective, mission-critical software at scale need not be complicated. Serving the public by fulfilling their online requests quickly, reliably, without undue hassle, regardless of how many people come at once, respects their time and humanity, and improves their overall experience with their government.

Read the whole story
3 days ago
Share this story

Our public inquiry on buy now, pay later

1 Share

Several weeks ago, we issued a market-monitoring inquiry into “buy now, pay later” (BNPL) products and business practices. Now we are inviting anyone interested in this market to submit comments -- including families, small businesses, and international regulators.

Read the whole story
9 days ago
Share this story

Doodled Dragons takes at least $30,000 after tweeting "our charity will instead now be... my bank account"

1 Comment
A pink dragon blowing smoke out its nostrils, wearing a blue hoodie.

A verified NFT project on the Solana blockchain, Doodled Dragons, touted that they would distribute all profits "straight to charities protecting animals on the brink of extinction". They announced on Twitter that they would be donating $30,000, "our first donation", to the World Wildlife Fund. Two hours later, they tweeted, "actually. fuck that. our charity will instead now be... my bank account. cya nerds." They deleted the Twitter account shortly after.

Read the whole story
12 days ago
Share this story

Do You Speak the Lingo?

1 Share

I’ve been spending some time lately contributing to ScummVM, an open-source reimplementation of many different game engines that makes it possible to play those games on countless modern platforms. They’ve recently added support for Macromedia Director, an engine used by a ton of 90s computer games and multimedia software that I’m really passionate about, so I wanted to get involved and help out.

One of the first games I tried out is Difficult Book Game (Muzukashii Hon wo Yomu to Nemukunaru, or Reading a Difficult Book Makes You Sleepy), a small puzzle game for the Mac by a one-person indie studio called Itachoco Systems that specialized in strange, interesting art games. Players take on the role of a woman named Miss Linli who, after falling asleep reading a complicated book, finds herself in a strange lucid dream where gnomes are crawling all over her table. Players can entice them to climb on her or scoop them up with her hands. If two gnomes walk into each other, they turn into a strange seed that, in turn, grows into other strange things if it comes into contact with another gnome. Players guide her using what feels like an early ancestor to QWOP, with separate keys controlling the joints on each of Linli’s arms. It’s bizarre, difficult to control, and compelling.

A lot of early Director games play fine in ScummVM without any special work, so I was hoping that would be true here too. Unfortunately, it didn’t turn out to be quite that simple. I ended up taking a dive into ScummVM’s implementation of Director to fix it.

Director uses its own programming language, Lingo, which is inspired by languages like Smalltalk and HyperCard. HyperCard was Apple’s hypermedia development environment, released for Macs in 1987, and was known for its simple, English-like, non-programmer friendly programming language. Smalltalk, meanwhile, is a programming language developed in the 70s and 80s known for its simple syntax and powerful object oriented features, very new at the time; it’s also influenced other modern languages such as Python and Ruby. Lingo uses a HyperCard-style English-like way of programming and Smalltalk-style object oriented features.

Early versions of Director are unusual for having the engine interpret the game logic straight from source code1—which means if you’ve got any copy of the game, you’ve got the source code too. It’s great for debugging and learning how it works, but there’s a downside too. If you’re writing a new interpreter, like ScummVM, it means you have to deal with writing a parser for arbitrary source code. As it turns out, every issue I’d have to deal with to get this game working involved the parser.

I’ll get into the details later, but first some background. To give a simplified view, ScummVM processes Lingo source in a few steps. First, it translates the text from its source encoding to Unicode; since Lingo dates to before Unicode was widely used, each script is stored in a language-specific encoding and needs to be translated in order for modern Unicode-native software to interpret it correctly. Next, there’s a preprocessing stage in which a few transformations are made in order to make the later stages simpler. The output of this stage is still text which carries the same technical meaning, it’s just text that’s easier for the next stages to process. This is followed by the two stages of the actual parser itself: the lexer, in which source code text is converted into a series of tokens, and the parser, which has a definition of the grammar for the language and interprets the tokens from the previous stage in the context of that grammar.

This all sounds complicated, but my changes ended up being pretty small. They did, however, end up getting spread across several of these layers.

1. The fun never ends!

The very first thing I got after launching the game was this parse error:

WARNING: ######################  LINGO: syntax error, unexpected tMETHOD: expected end of file at line 83 col 6 in MovieScript id: 0!

Taking a look at the code in question, there’s nothing that really looks too out of the ordinary:

factory lady
method mNew
    instance rspri,rx,ry,rhenka,rkihoncala,rflag,rhoko,rkasoku
end method
method mInit1 spri
# etc

This is the start of the definition of the game’s first factory. Lingo supports object-oriented features, something that was still pretty new when it was introduced, and allows for user-defined classes called “factories”2. Following the factory lady definition are a number of methods, defined in a block-like format: method NAME, an indented set of one or more lines of method definitions, and an end method line.

That last line, it turns out, was the problem. To my surprise, it turns out those end method blocks are totally optional even though it’s the documented syntax in the official Director manual. Not only can it have any text there instead of method, but it turns out you don’t need any form of end statement at all. If ScummVM didn’t recognize it, it seems that many games must have just skipped it.

Luckily, this was a very easy fix: I added a single line to ScummVM’s Bison-based parser and it was able to handle end statements without breaking support for methods defined without them. I hoped that was all it was going to take for Difficult Book Game to run, but I wasn’t quite so lucky.

2. Language-dependent syntax

Unlike most modern languages, Lingo doesn’t have a general-purpose escape character like \ that can be use to extend a line of code across multiple lines. Instead, it uses a special character called the “continuation marker”, ¬3, which serves that purpose and is used for nothing else in the language4. (Hope you like holding down keys to type special characters!) Here’s an example of how that looks with a couple lines of code from a real application:

global theObjects,retdata1,retdata2,ladytime,selif,daiido,Xzahyo,Yzahyo,StageNum, ¬

Since Lingo was originally written for the Mac, whose default MacRoman character set supported a number of “special” characters and accents outside the normal ASCII range, they were able to get away with characters that might not be safe in other programming languages. But there’s a problem there, and not just that it was annoying to type: what happens if you’re programming in a language that doesn’t use MacRoman? This is before Unicode, so each language was using a different encoding, and there’s no guarantee that a given language would have ¬ in its character set.

Which takes me back to Difficult Book Game. I tried running it again after the fix above, only to run into a new parse error. After checking the lines of code it was talking about, I ran into something that looks almost like the code above… almost.

global theObjects,retdata1,retdata2,ladytime,selif,daiido,Xzahyo,Yzahyo,StageNum, ツ

Spot the difference? In the place where the continuation marker should be, there’s something else: , or the halfwidth katakana character “tsu”. As it turns out, that’s not random. In MacRoman, ¬ takes up the character position 0xC2, and is at the same location in MacJapanese. That, it turns out, seems to be the answer of how the continuation marker is handled in different languages. It’s not really ¬, it’s whatever character happens to be at 0xC2 in a given text encoding.

Complicating things a bit, ScummVM handles lexing Lingo after translating the code from its source encoding to UTF-8. If it lexed the raw bytes, it would be one thing: whatever the character is at 0xC2 is the continuation marker, regardless of what character it “means”. Handling it after it’s been turned into Unicode is a lot harder. Since ScummVM already has a Lingo preprocessor, though, it could get fixed up there: just look for instances of followed by a newline, and treat that as though it’s a “real” continuation marker5. A little crude, but it works, and suddenly ScummVM could parse Difficult Book Game’s code6. Or, almost…

3. What’s in a space?

Now that I could finally get in-game, I could start messing around with the controls and see how it ran. Characters were moving, controls were responding—it was looking good! At least until I pressed a certain key…

Her arms detached—that doesn’t look comfortable. In the console, ScummVM flagged an error that looked relevant:

Incorrect number of arguments for handler mLHizikaraHand (1, expected 3 to 3). Adding extra 2 voids!

This sounded relevant, since “hiji” means elbow. I figured it was probably the handler called when rotating her arm around her elbow, which is exactly what visually broke. I took a look at where mLHizikaraHand and the similar handlers were being called, and noticed something weird. In some places, it looks like this:

locaobject(mLHizikaraHand,(rhenka + 1),dotti)

And in other places, it looked slightly different:

locaobject(mLHizikaraHand (rhenka + 1),dotti)

Can you find the difference? It’s the character immediately after the handler name: instead of a comma, it’s followed by a space. Now that I looked at it, the ScummVM error actually sounded right. It does look like it’s calling mLHizikaraHand with a single argument (rhenka + 1). After talking it over with ScummVM dev djsrv, it sounds like this is just a Lingo parsing oddity. Lingo was designed to be a user-friendly language, and there are plenty of cases where its permissive parser accepts things that most languages would reject. This seems to be one of them.

Unfortunately, this parse case also seems to be different between Lingo versions. Fixing how it interprets it might have knock-on effects for parsing things created for later Director releases. Time to get hacky instead. The good news is that ScummVM has a mechanism for exactly this: it bundles patches for various games, making it possible to fix up weird and ambiguous syntax that its parser can’t handle yet. I added patches to change the ambiguous cases to the syntax used elsewhere, and suddenly Miss Linli’s posture is looking a lot healthier.

This whole thing ended up being much more of a journey than I expected. So much for having it just run! In the end, though, I learned quite a bit—and I was able to get a cool game to run on modern OSs. I’m continuing to work on ScummVM’s Director support and should have more to write about later.

Thanks to ScummVM developers djsrv and sev for their help working on this.

  1. Later versions switched to using a bytecode format, similar to Java or C#. This makes processing a lot easier, since bytecode produced by Director’s own compiler is far more standardized than human-written source code.

  2. Despite the name, it isn’t really implementing the factory pattern.

  3. The mathematical negation operator.

  4. It’s a bit of a weird choice, but Lingo didn’t do it first. It showed up first in Apple’s HyperCard and AppleScript languages.

  5. Tempting as it is to refactor the lexer, I had other things to do, and I really wasn’t familiar enough with its innards to take that on.

  6. As it turns out, this wasn’t the only game with the same issue. Fixing this also fixed several other Japanese games, including The Seven Colors: Legend of Psy・S City and Eriko Tamura’s Oz.

Read the whole story
15 days ago
Share this story

A DAO forms with the goal of "liberating" Blockbuster, hoping to raise $5 million from NFTs

1 Share
Tweet from BlockbusterDAO (@BlockbusterDAO): "Our mission is to liberate Blockbuster and form a DAO to collectively govern the brand as we turn Blockbuster into the first-ever DeFilm streaming platform and a mainstay of both the Web3 brands and products, but a powerhouse in the future of the film industry. Read the 🧵👇"

A group called "BlockbusterDAO" emerged, with the stated goal of "liberat[ing] Blockbuster and form[ing] a DAO to collectively govern the brand as we turn Blockbuster into the first-ever DeFilm streaming platform". Ideas for the DAO's plans after buying the corporation included creating original films and also getting into crypto gaming, for some reason. Some outlets noted that it's unlikely Dish, the current owner of Blockbuster, would sell the corporation for any amount (and particularly for an amount $315 million less than what it bought them for ten years ago), but I suspect that minor detail is unlikely to slow the group down much.

Read the whole story
21 days ago
Share this story
Next Page of Stories