10 interesting stories served every morning and every evening.
Language models today, while useful for a variety of tasks, are still limited. The only information they can learn from is their training data. This information can be out-of-date and is one-size fits all across applications. Furthermore, the only thing language models can do out-of-the-box is emit text. This text can contain useful instructions, but to actually follow these instructions you need another process.
Though not a perfect analogy, plugins can be “eyes and ears” for language models, giving them access to information that is too recent, too personal, or too specific to be included in the training data. In response to a user’s explicit request, plugins can also enable language models to perform safe, constrained actions on their behalf, increasing the usefulness of the system overall.
We expect that open standards will emerge to unify the ways in which applications expose an AI-facing interface. We are working on an early attempt at what such a standard might look like, and we’re looking for feedback from developers interested in building with us.
Today, we’re beginning to gradually enable existing plugins from our early collaborators for ChatGPT users, beginning with ChatGPT Plus subscribers. We’re also beginning to roll out the ability for developers to create their own plugins for ChatGPT.
In the coming months, as we learn from deployment and continue to improve our safety systems, we’ll iterate on this protocol, and we plan to enable developers using OpenAI models to integrate plugins into their own applications beyond ChatGPT.
...
Read the original on openai.com »
/ Sign up for Verge Deals to get deals on products we’ve tested sent to your inbox daily.
...
Read the original on www.theverge.com »
Now available with AMD Ryzen™ 7040 Series and 13th Gen Intel® Core™
Performance upgrades for your Framework Laptop 13, with the latest Intel and AMD processor options.
Higher-capacity batteries, improved hinges, matte displays, and more for your Framework Laptop 13.
Get the latest news and product updates from Framework
“The team over at Framework has managed to not just create a laptop that is easily repairable and upgradable, but it‘s also a thin, gorgeous, performant laptop.” — Linus Tech Tips
“This is the best laptop you can get right now if you want a completely repairable and upgradeable device.” — Dave2D
Best of the Best Design Award
The time has come for consumer electronics products that are designed to last: products that give you back the power to upgrade, customize, and repair them. We’re excited for the opportunity to fix the consumer electronics industry together.
At our Next Level Event, we launched a colossal set of new products and upgrades, including the new, high-performance 16” Framework Laptop 16 and both Intel and AMD-powered Framework Laptop 13. We can’t wait to see what you think!
...
Read the original on frame.work »
Early in January I wrote about the possibility of connecting ChatGPT to Wolfram|Alpha. And today—just two and a half months later—I’m excited to announce that it’s happened! Thanks to some heroic software engineering by our team and by OpenAI, ChatGPT can now call on Wolfram|Alpha—and Wolfram Language as well—to give it what we might think of as “computational superpowers”. It’s still very early days for all of this, but it’s already very impressive—and one can begin to see how amazingly powerful (and perhaps even revolutionary) what we can call “” can be.
Back in January, I made the point that, as an LLM neural net, ChatGPT—for all its remarkable prowess in textually generating material “like” what it’s read from the web, etc.—can’t itself be expected to do actual nontrivial computations, or to systematically produce correct (rather than just “looks roughly right”) data, etc. But when it’s connected to the Wolfram plugin it can do these things. So here’s my (very simple) first example from January, but now done by ChatGPT with “Wolfram superpowers” installed:
It’s a correct result (which in January it wasn’t)—found by actual computation. And here’s a bonus: immediate visualization:
How did this work? Under the hood, ChatGPT is formulating a query for Wolfram|Alpha—then sending it to Wolfram|Alpha for computation, and then “deciding what to say” based on reading the results it got back. You can see this back and forth by clicking the “Used Wolfram” box (and by looking at this you can check that ChatGPT didn’t “make anything up”):
There are lots of nontrivial things going on here, on both the ChatGPT and Wolfram|Alpha sides. But the upshot is a good, correct result, knitted into a nice, flowing piece of text.
Let’s try another example, also from what I wrote in January:
A fine result, worthy of our technology. And again, we can get a bonus:
In January, I noted that ChatGPT ended up just “making up” plausible (but wrong) data when given this prompt:
But now it calls the Wolfram plugin and gets a good, authoritative answer. And, as a bonus, we can also make a visualization:
Another example from back in January that now comes out correctly is:
If you actually try these examples, don’t be surprised if they work differently (sometimes better, sometimes worse) from what I’m showing here. Since ChatGPT uses randomness in generating its responses, different things can happen even when you ask it the exact same question (even in a fresh session). It feels “very human”. But different from the solid “right-answer-and-it-doesn’t-change-if-you-ask-it-again” experience that one gets in Wolfram|Alpha and Wolfram Language.
Here’s an example where we saw ChatGPT (rather impressively) “having a conversation” with the Wolfram plugin, after at first finding out that it got the “wrong Mercury”:
One particularly significant thing here is that ChatGPT isn’t just using us to do a “dead-end” operation like show the content of a webpage. Rather, we’re acting much more like a true “brain implant” for ChatGPT—where it asks us things whenever it needs to, and we give responses that it can weave back into whatever it’s doing. It’s rather impressive to see in action. And—although there’s definitely much more polishing to be done—what’s already there goes a long way towards (among other things) giving ChatGPT the ability to deliver accurate, curated knowledge and data—as well as correct, nontrivial computations.
But there’s more too. We already saw examples where we were able to provide custom-created visualizations to ChatGPT. And with our computation capabilities we’re routinely able to make “truly original” content—computations that have simply never been done before. And there’s something else: while “pure ChatGPT” is restricted to things it “learned during its training”, by calling us it can get up-to-the-moment data.
This can be based on our real-time data feeds (here we’re getting called twice; once for each place):
Or it can be based on “science-style” predictive computations:
And now (almost) all of this is accessible to ChatGPT—opening up a tremendous breadth and depth of new possibilities. And to give some sense of these, here are a few (simple) examples:
ChatGPT is built to be able to have back-and-forth conversation with humans. But what can one do when that conversation has actual computation and computational knowledge in it? Here’s an example. Start by asking a “world knowledge” question:
And, yes, by “opening the box” one can check that the right question was asked to us, and what the raw response we gave was. But now we can go on and ask for a map:
But there are “prettier” map projections we could have used. And with ChatGPT’s “general knowledge” based on its reading of the web, etc. we can just ask it to use one:
But maybe we want a heat map instead. Again, we can just ask it to produce this—underneath using our technology:
Let’s change the projection again, now asking it again to pick it using its “general knowledge”:
And, yes, it got the projection “right”. But not the centering. So let’s ask it to fix that:
OK, so what do we have here? We’ve got something that we “collaborated” to build. We incrementally said what we wanted; the AI (i.e. ) progressively built it. But what did we actually get? Well, it’s a piece of Wolfram Language code—which we could see by “opening the box”, or just asking ChatGPT for:
If we copy the code out into a Wolfram Notebook, we can immediately run it, and we find it has a nice “luxury feature”—as ChatGPT claimed in its description, there are dynamic tooltips giving the name of each country:
What’s happening “under the hood” with ChatGPT and the Wolfram plugin? Remember that the core of ChatGPT is a “large language model” (LLM) that’s trained from the web, etc. to generate a “reasonable continuation” from any text it’s given. But as a final part of its training ChatGPT is also taught how to “hold conversations”, and when to “ask something to someone else”—where that “someone” might be a human, or, for that matter, a plugin. And in particular, it’s been taught when to reach out to the Wolfram plugin.
The Wolfram plugin actually has two entry points: a Wolfram|Alpha one and a Wolfram Language one. The Wolfram|Alpha one is in a sense the “easier” for ChatGPT to deal with; the Wolfram Language one is ultimately the more powerful. The reason the Wolfram|Alpha one is easier is that what it takes as input is just natural language—which is exactly what ChatGPT routinely deals with. And, more than that, Wolfram|Alpha is built to be forgiving—and in effect to deal with “typical human-like input”, more or less however messy that may be.
Wolfram Language, on the other hand, is set up to be precise and well defined—and capable of being used to build arbitrarily sophisticated towers of computation. Inside Wolfram|Alpha, what it’s doing is to translate natural language to precise Wolfram Language. In effect it’s catching the “imprecise natural language” and “funneling it” into precise Wolfram Language.
When ChatGPT calls the Wolfram plugin it often just feeds natural language to Wolfram|Alpha. But ChatGPT has by this point learned a certain amount about writing Wolfram Language itself. And in the end, as we’ll discuss later, that’s a more flexible and powerful way to communicate. But it doesn’t work unless the Wolfram Language code is exactly right. To get it to that point is partly a matter of training. But there’s another thing too: given some candidate code, the Wolfram plugin can run it, and if the results are obviously wrong (like they generate lots of errors), ChatGPT can attempt to fix it, and try running it again. (More elaborately, ChatGPT can try to generate tests to run, and change the code if they fail.)
There’s more to be developed here, but already one sometimes sees ChatGPT go back and forth multiple times. It might be rewriting its Wolfram|Alpha query (say simplifying it by taking out irrelevant parts), or it might be deciding to switch between Wolfram|Alpha and Wolfram Language, or it might be rewriting its Wolfram Language code. Telling it how to do these things is a matter for the initial “plugin prompt”.
And writing this prompt is a strange activity—perhaps our first serious experience of trying to “communicate with an alien intelligence”. Of course it helps that the “alien intelligence” has been trained with a vast corpus of human-written text. So, for example, it knows English (a bit like all those corny science fiction aliens…). And we can tell it things like “If the user input is in a language other than English, translate to English and send an appropriate query to Wolfram|Alpha, then provide your response in the language of the original input.”
Sometimes we’ve found we have to be quite insistent (note the all caps): “When writing Wolfram Language code, NEVER use snake case for variable names; ALWAYS use camel case for variable names.” And even with that insistence, ChatGPT will still sometimes do the wrong thing. The whole process of “prompt engineering” feels a bit like animal wrangling: you’re trying to get ChatGPT to do what you want, but it’s hard to know just what it will take to achieve that.
Eventually this will presumably be handled in training or in the prompt, but as of right now, ChatGPT sometimes doesn’t know when the Wolfram plugin can help. For example, ChatGPT guesses that this is supposed to be a DNA sequence, but (at least in this session) doesn’t immediately think the Wolfram plugin can do anything with it:
Say “Use Wolfram”, though, and it’ll send it to the Wolfram plugin, which indeed handles it nicely:
When the Wolfram plugin is given Wolfram Language code, what it does is basically just to evaluate that code, and return the result—perhaps as a graphic or math formula, or just text. But when it’s given Wolfram|Alpha input, this is sent to a special Wolfram|Alpha “for LLMs” API endpoint, and the result comes back as text intended to be “read” by ChatGPT, and effectively used as an additional prompt for further text ChatGPT is writing. Take a look at this example:
The result is a nice piece of text containing the answer to the question asked, along with some other information ChatGPT decided to include. But “inside” we can see what the Wolfram plugin (and the Wolfram|Alpha “LLM endpoint”) actually did:
There’s quite a bit of additional information there (including some nice pictures!). But ChatGPT “decided” just to pick out a few pieces to include in its response.
By the way, something to emphasize is that if you want to be sure you’re getting what you think you’re getting, always check what ChatGPT actually sent to the Wolfram plugin—and what the plugin returned. One of the important things we’re adding with the Wolfram plugin is a way to “factify” ChatGPT output—and to know when ChatGPT is “using its imagination”, and when it’s delivering solid facts.
Sometimes in trying to understand what’s going on it’ll also be useful just to take what the Wolfram plugin was sent, and enter it as direct input on the Wolfram|Alpha website, or in a Wolfram Language system (such as the Wolfram Cloud).
One of the great (and, frankly, unexpected) things about ChatGPT is its ability to start from a rough description, and generate from it a polished, finished output—such as an essay, letter, legal document, etc. In the past, one might have tried to achieve this “by hand” by starting with “boilerplate” pieces, then modifying them, “gluing” them together, etc. But ChatGPT has all but made this process obsolete. In effect, it’s “absorbed” a huge range of boilerplate from what it’s “read” on the web, etc.—and now it typically does a good job at seamlessly “adapting it” to what you need.
So what about code? In traditional programming languages writing code tends to involve a lot of “boilerplate work”—and in practice many programmers in such languages spend lots of their time building up their programs by copying big slabs of code from the web. But now, suddenly, it seems as if ChatGPT can make much of this obsolete. Because it can effectively put together essentially any kind of boilerplate code automatically—with only a little “human input”.
Of course, there has to be some human input—because otherwise ChatGPT wouldn’t know what program it was supposed to write. But—one might wonder—why does there have to be “boilerplate” in code at all? Shouldn’t one be able to have a language where—just at the level of the language itself—all that’s needed is a small amount of human input, without any of the “boilerplate dressing”?
Well, here’s the issue. Traditional programming languages are centered around telling a computer what to do in the computer’s terms: set this variable, test that condition, etc. But it doesn’t have to be that way. And instead one can start from the other end: take things people naturally think in terms of, then try to represent these computationally—and effectively automate the process of getting them actually implemented on a computer.
Well, this is what I’ve now spent more than four decades working on. And it’s the foundation of what’s now Wolfram Language—which I now feel justified in calling a “full-scale computational language”. What does this mean? It means that right in the language there’s a computational representation for both abstract and real things that we talk about in the world, whether those are graphs or images or differential equations—or cities or chemicals or companies or movies.
Why not just start with natural language? Well, that works up to a point—as the success of Wolfram|Alpha demonstrates. But once one’s trying to specify something more elaborate, natural language becomes (like “legalese”) at best unwieldy—and one really needs a more structured way to express oneself.
There’s a big example of this historically, in mathematics. Back before about 500 years ago, pretty much the only way to “express math” was in natural language. But then mathematical notation was invented, and math took off—with the development of algebra, calculus, and eventually all the various mathematical sciences.
My big goal with the Wolfram Language is to create a computational language that can do the same kind of thing for anything that can be “expressed computationally”. And to achieve this we’ve needed to build a language that both automatically does a lot of things, and intrinsically knows a lot of things. But the result is a language that’s set up so that people can conveniently “express themselves computationally”, much as traditional mathematical notation lets them “express themselves mathematically”. And a critical point is that—unlike traditional programming languages—Wolfram Language is intended not just for computers, but also for humans, to read. In other words, it’s intended as a structured way of “communicating computational ideas”, not just to computers, but also to humans.
But now—with ChatGPT—this suddenly becomes even more important than ever before. Because—as we began to see above—ChatGPT can work with Wolfram Language, in a sense building up computational ideas just using natural language. And part of what’s then critical is that Wolfram Language can directly represent the kinds of things we want to talk about. But what’s also critical is that it gives us a way to “know what we have”—because we can realistically and economically read Wolfram Language code that ChatGPT has generated.
The whole thing is beginning to work very nicely with the Wolfram plugin in ChatGPT. Here’s a simple example, where ChatGPT can readily generate a Wolfram Language version of what it’s being asked:
And the critical point is that the “code” is something one can realistically expect to read (if I were writing it, I would use the slightly more compact function):
I might have written the code a little differently, but this is again something very readable:
It’s often possible to use a pidgin of Wolfram Language and English to say what you want:
Here’s an example where ChatGPT is again successfully constructing Wolfram Language—and conveniently shows it to us so we can confirm that, yes, it’s actually computing the right thing:
And, by the way, to make this work it’s critical that the Wolfram Language is in a sense “self-contained”. This piece of code is just standard generic Wolfram Language code; it doesn’t depend on anything outside, and if you wanted to, you could look up the definitions of everything that appears in it in the Wolfram Language documentation.
OK, one more example:
Obviously ChatGPT had trouble here. But—as it suggested—we can just run the code it generated, directly in a notebook. And because Wolfram Language is symbolic, we can explicitly see results at each step:
So close! Let’s help it a bit, telling it we need an actual list of European countries:
And there’s the result! Or at least, a result. Because when we look at this computation, it might not be quite what we want. For example, we might want to pick out multiple dominant colors per country, and see if any of them are close to purple. But the whole Wolfram Language setup here makes it easy for us to “collaborate with the AI” to figure out what we want, and what to do.
So far we’ve basically been starting with natural language, and building up Wolfram Language code. But we can also start with pseudocode, or code in some low-level programming language. And ChatGPT tends to do a remarkably good job of taking such things and producing well-written Wolfram Language code from them. The code isn’t always exactly right. But one can always run it (e.g. with the Wolfram plugin) and see what it does, potentially (courtesy of the symbolic character of Wolfram Language) line by line. And the point is that the high-level computational language nature of the Wolfram Language tends to allow the code to be sufficiently clear and (at least locally) simple that (particularly after seeing it run) one can readily understand what it’s doing—and then potentially iterate back and forth on it with the AI.
When what one’s trying to do is sufficiently simple, it’s often realistic to specify it—at least if one does it in stages—purely with natural language, using Wolfram Language “just” as a way to see what one’s got, and to actually be able to run it. But it’s when things get more complicated that Wolfram Language really comes into its own—providing what’s basically the only viable human-understandable-yet-precise representation of what one wants.
And when I was writing my book An Elementary Introduction to the Wolfram Language this became particularly obvious. At the beginning of the book I was easily able to make up exercises where I described what was wanted in English. But as things started getting more complicated, this became more and more difficult. As a “fluent” user of Wolfram Language I usually immediately knew how to express what I wanted in Wolfram Language. But to describe it purely in English required something increasingly involved and complicated, that read like legalese.
But, OK, so you specify something using Wolfram Language. Then one of the remarkable things ChatGPT is often able to do is to recast your Wolfram Language code so that it’s easier to read. It doesn’t (yet) always get it right. But it’s interesting to see it make different tradeoffs from a human writer of Wolfram Language code. For example, humans tend to find it difficult to come up with good names for things, making it usually better (or at least less confusing) to avoid names by having sequences of nested functions. But ChatGPT, with its command of language and meaning, has a fairly easy time making up reasonable names. And although it’s something I, for one, did not expect, I think using these names, and “spreading out the action”, can often make Wolfram Language code even easier to read than it was before, and indeed read very much like a formalized analog of natural language—that we can understand as easily as natural language, but that has a precise meaning, and can actually be run to generate computational results.
If you “know what computation you want to do”, and you can describe it in a short piece of natural language, then Wolfram|Alpha is set up to directly do the computation, and present the results in a way that is “visually absorbable” as easily as possible. But what if you want to describe the result in a narrative, textual essay? Wolfram|Alpha has never been set up to do that. But ChatGPT is.
And here within ChatGPT we’re asking for this same Wolfram|Alpha result, but then telling ChatGPT to “make an essay out of it”:
Another “old chestnut” for Wolfram|Alpha is math word problems. Given a “crisply presented” math problem, Wolfram|Alpha is likely to do very well at solving it. But what about a “woolly” word problem? Well, ChatGPT is pretty good at “unraveling” such things, and turning them into “crisp math questions”—which then the Wolfram plugin can now solve. Here’s an example:
Here’s a slightly more complicated case, including a nice use of “common sense” to recognize that the number of turkeys cannot be negative:
Beyond math word problems, another “old chestnut” now addressed by is what physicists tend to call “Fermi problems”: order-of-magnitude estimates that can be made on the basis of quantitative knowledge about the world. Here’s an example:
is something very new—really a completely new kind of technology. And as happens whenever a new kind of technology arrives, it’s opening up tremendous new opportunities. Some of these we can already begin to to see—but lots of others will emerge over the weeks, months and years to come.
So how can you get involved in what promises to be an exciting period of rapid technological—and conceptual—growth? The first thing is just to explore . ChatGPT and Wolfram are each on their own vast systems; the combination of them is something that it’ll take years to fully plumb. But the first step is just to get a sense of what’s possible.
Find examples. Share them. Try to identify successful patterns of usage. And, most of all, try to find workflows that deliver the highest value. Those workflows could be quite elaborate. But they could also be quite simple—cases where once one sees what can be done, there’s an immediate “aha”.
How can you best implement a workflow? Well, we’re trying to work out the best workflows for that. Within Wolfram Language we’re setting up flexible ways to call on things like ChatGPT, both purely programmatically, and in the context of the notebook interface.
But what about from the ChatGPT side? Wolfram Language has a very open architecture, where a user can add or modify pretty much whatever they want. But how can you use this from ChatGPT? One thing is just to tell ChatGPT to include some specific piece of “initial” Wolfram Language code (maybe together with documentation)—then use something like the pidgin above to talk to ChatGPT about the functions or other things you’ve defined in that initial code.
We’re planning to build increasingly streamlined tools for handling and sharing Wolfram Language code for use through ChatGPT. But one approach that already works is to submit functions for publication in the Wolfram Function Repository, then—once they’re published—refer to these functions in your conversation with ChatGPT.
OK, but what about within ChatGPT itself? What kind of prompt engineering should you do to best interact with the Wolfram plugin? Well, we don’t know yet. It’s something that has to be explored—in effect as an exercise in AI education or AI psychology. A typical approach is to give some “pre-prompts” earlier in your ChatGPT session, then hope it’s “still paying attention” to those later on. (And, yes, it has a limited “attention span”, so sometimes things have to get repeated.)
We’ve tried to give an overall prompt to tell ChatGPT basically how to use the Wolfram plugin—and we fully expect this prompt to evolve rapidly, as we learn more, and as the ChatGPT LLM is updated. But you can add your own general pre-prompts, saying things like “When using Wolfram always try to include a picture” or “Use SI units” or “Avoid using complex numbers if possible”.
You can also try setting up a pre-prompt that essentially “defines a function” right in ChatGPT—something like: “If I give you an input consisting of a number, you are to use Wolfram to draw a polygon with that number of sides”. Or, more directly, “If I give you an input consisting of numbers you are to apply the following Wolfram function to that input …”, then give some explicit Wolfram Language code.
But these are very early days, and no doubt there’ll be other powerful mechanisms discovered for “programming” . And I think we can confidently expect that the next little while will be an exciting time of high growth, where there’s lots of valuable “low-hanging fruit” to be picked by those who chose to get involved.
Even a week ago it wasn’t clear what was going to be like—or how well it was going to work. But these things that are now moving so quickly are built on decades of earlier development. And in some ways the arrival of finally marries the two main approaches historically taken to AI—that have long been viewed as disjoint and incompatible.
ChatGPT is basically a very large neural network, trained to follow the “statistical” patterns of text it’s seen on the web, etc. The concept of neural networks—in a form surprisingly close to what’s used in ChatGPT—originated all the way back in the 1940s. But after some enthusiasm in the 1950s, interest waned. There was a resurgence in the early 1980s (and indeed I myself first looked at neural nets then). But it wasn’t until 2012 that serious excitement began to build about what might be possible with neural nets. And now a decade later—in a development whose success came as a big surprise even to those involved—we have ChatGPT.
Rather separate from the “statistical” tradition of neural nets is the “symbolic” tradition for AI. And in a sense that tradition arose as an extension of the process of formalization developed for mathematics (and mathematical logic), particularly near the beginning of the twentieth century. But what was critical about it was that it aligned well not only with abstract concepts of computation, but also with actual digital computers of the kind that started to appear in the 1950s.
The successes in what could really be considered “AI” were for a long time at best spotty. But all the while, the general concept of computation was showing tremendous and growing success. But how might “computation” be related to ways people think about things? For me, a crucial development was my idea at the beginning of the 1980s (building on earlier formalism from mathematical logic) that transformation rules for symbolic expressions might be a good way to represent computations at what amounts to a “human” level.
At the time my main focus was on mathematical and technical computation, but I soon began to wonder whether similar ideas might be applicable to “general AI”. I suspected something like neural nets might have a role to play, but at the time I only figured out a bit about what would be needed—and not how to achieve it. Meanwhile, the core idea of transformation rules for symbolic expressions became the foundation for what’s now the Wolfram Language—and made possible the decades-long process of developing the full-scale computational language that we have today.
Starting in the 1960s there’d been efforts among AI researchers to develop systems that could “understand natural language”, and “represent knowledge” and answer questions from it. Some of what was done turned into less ambitious but practical applications. But generally success was elusive. Meanwhile, as a result of what amounted to a philosophical conclusion of basic science I’d done in the 1990s, I decided around 2005 to make an attempt to build a general “computational knowledge engine” that could broadly answer factual and computational questions posed in natural language. It wasn’t obvious that such a system could be built, but we discovered that—with our underlying computational language, and with a lot of work—it could. And in 2009 we were able to release Wolfram|Alpha.
And in a sense what made Wolfram|Alpha possible was that internally it had a clear, formal way to represent things in the world, and to compute about them. For us, “understanding natural language” wasn’t something abstract; it was the concrete process of translating natural language to structured computational language.
Another part was assembling all the data, methods, models and algorithms needed to “know about” and “compute about” the world. And while we’ve greatly automated this, we’ve still always found that to ultimately “get things right” there’s no choice but to have actual human experts involved. And while there’s a little of what one might think of as “statistical AI” in the natural language understanding system of Wolfram|Alpha, the vast majority of Wolfram|Alpha—and Wolfram Language—operates in a hard, symbolic way that’s at least reminiscent of the tradition of symbolic AI. (That’s not to say that individual functions in Wolfram Language don’t use machine learning and statistical techniques; in recent years more and more do, and the Wolfram Language also has a whole built-in framework for doing machine learning.)
As I’ve discussed elsewhere, what seems to have emerged is that “statistical AI”, and particularly neural nets, are well suited for tasks that we humans “do quickly”, including—as we learn from ChatGPT—natural language and the “thinking” that underlies it. But the symbolic and in a sense “more rigidly computational” approach is what’s needed when one’s building larger “conceptual” or computational “towers”—which is what happens in math, exact science, and now all the “computational X” fields.
And now can be thought of as the first truly large-scale statistical + symbolic “AI” system. In Wolfram|Alpha (which became an original core part of things like the Siri intelligent assistant) there was for the first time broad natural language understanding—with “understanding” directly tied to actual computational representation and computation. And now, 13 years later, we’ve seen in ChatGPT that pure “statistical” neural net technology, when trained from almost the entire web, etc. can do remarkably well at “statistically” generating “human-like” “meaningful language”. And in we’re now able to leverage the whole stack: from the pure “statistical neural net” of ChatGPT, through the “computationally anchored” natural language understanding of Wolfram|Alpha, to the whole computational language and computational knowledge of Wolfram Language.
When we were first building Wolfram|Alpha we thought that perhaps to get useful results we’d have no choice but to engage in a conversation with the user. But we discovered that if we immediately generated rich, “visually scannable” results, we only needed a simple “Assumptions” or “Parameters” interaction—at least for the kind of information and computation seeking we expected of our users. (In Wolfram|Alpha Notebook Edition we nevertheless have a powerful example of how multistep computation can be done with natural language.)
Back in 2010 we were already experimenting with generating not just the Wolfram Language code of typical Wolfram|Alpha queries from natural language, but also “whole programs”. At the time, however—without modern LLM technology—that didn’t get all that far. But what we discovered was that—in the context of the symbolic structure of the Wolfram Language—even having small fragments of what amounts to code be generated by natural language was extremely useful. And indeed I, for example, use the mechanism in Wolfram Notebooks countless times almost every day, for example to construct symbolic entities or quantities from natural language. We don’t yet know quite what the modern “LLM-enabled” version of this will be, but it’s likely to involve the rich human-AI “collaboration” that we discussed above, and that we can begin to see in action for the first time in .
I see what’s happening now as a historic moment. For well over half a century the statistical and symbolic approaches to what we might call “AI” evolved largely separately. But now, in they’re being brought together. And while we’re still just at the beginning with this, I think we can reasonably expect tremendous power in the combination—and in a sense a new paradigm for “AI-like computation”, made possible by the arrival of ChatGPT, and now by its combination with Wolfram|Alpha and Wolfram Language in .
...
Read the original on writings.stephenwolfram.com »
My phone pinged: “Tell Mark Essien they are coming for him.”
I had no idea what that even meant. It was a forwarded WhatsApp message that someone had sent to a friend of mine.
All I was doing was trying to convert PDFs from the 2023 Nigeria Presidential elections into spreadsheets.
But let’s rewind a bit and give some context.
In 2020 a small group of about 5 young people went to a crossroads in Lagos, Nigeria to protest against police brutality. Their protest was called #EndSARS, and they were protesting police brutality. SARS (The Special Anti-Robbery Squad) was a notorious segment of the Nigeria police force, known for extortion and extra-judicial killings of anybody they termed armed robbers.
For 4 days that tiny group protested, with barely anybody noticing.
On the last day, as they were about to leave, someone tweeted about their protest. Then someone else retweeted, and someone else. And soon, there thousands of retweets, with social media hailing them as heroes.
A few people who saw the protest on twitter joined them. It was still a small crowd, but it was growing. The news started spreading on social media, and the crowd grew. Within a couple of days, there were thousands of people protesting with the #EndSARS hashtag. The government was silent, believing it would blow away shortly.
But the protests grew and grew. Young people in other cities started joining. Nigerian social media was aflame - this was the only topic. Till the protests became violent. The protesters started attacking police stations. The policemen started shooting protesters.
The protesters marched to notorious SARS prisons and forced them open. Prisoners escaped. Malls were burnt down. Policemen threw off their uniforms and Government officials fled.
As the violence flared, social media now started calling for calm. But it was late - a lot of hoodlums had already infiltrated the protests, and they were bent on getting revenge for everything they blamed the Government for.
The Government tried to stop the protests, but there was nobody to talk to. There was no head of protest, no figurehead, nobody with any real authority. They called it a “headless mob”.
Social media started calling for calm, and asking the president to speak. After many days of silence, he finally spoke, urging for calm, disbanding SARS and promising to address the concerns of the protesters.
Things calmed down. But there was still a huge crowd gathered at the Lekki Tollgate - a major, 6 lane highway that passes through the heart of Lagos. Concerts were playing at the location, people were serving food and drinks.
Then ominously, on the 20th of October of 2020 some people drove there in unmarked cars and removed all the Cameras installed at the tollgate.
That night, as the DJs played, all the floodlights at the tollgate switched off. Social media users warned about military vehicles driving along the highway towards the location.
Short clips from mobile phones capture what happened next. It’s dark, people are running, gunshots everywhere. People are gathered around bleeding people, screaming. More running, lights flashing.
There are no cameras, so there is no clear reconstruction.
But the next morning, the army is in control of the tollgate, and the protesters are gone. Social media is filled with messages that many people were killed and the army took away their bodies and cleared the scene. The army and government said nothing like that happened.
There is a lot of anger, but the protests are over. Everything seems to be back to normal. But there is an under-current of youth anger.
And the presidential election is in 2023.
Nigeria has always been a two party state - much like the U. S. It uses pretty much the same presidential system as the U.S, and just like the Democrats and Republicans, there have been variants of the same two parties facing each other. Since 2011, it has been the PDP (former ruling party) against the APC (current ruling party).
In 2022, one of the candidates abruptly left the PDP, claiming that the process was rigged against him winning the nomination. He joined a small party that had only ever won one state governorship election in its entire history.
Suddenly, the social media mob adopted this candidate - Peter Obi - as their preferred candidate. Many of the same handles who had called out #EndSARS now became #Obidient. Tweets, WhatsApp messages grew, calling on others to join the #Obidient movement.
Peter Obi himself seemed as surprised as everyone else that the headless mob had adopted him, but he quickly accepted the Obidients, and started using the slogans as part of his campaign.
The political establishment mocked the movement, saying the “four people tweeting in a room” had never won even a council election in Nigeria.
The movement grew louder and louder on social media, with the members of the movement letting out their anger at the existing political institution. The politicians mocked back - saying that politics was not won on social media, but at the grassroots - referring to the villagers who normally vote for whoever gives them the most money.
Election Day came. The Labour Party candidate was Peter Obi, the candidate adopted by the young people on social media. The candidate from the ruling party was Bola Tinubu, former Governor of the most populous state (Lagos), and who has been involved in selecting every Governor to the state since he was Governor. He was also rumored to be getting a cut of all Lagos State tax revenue via a consulting firm he set up when he was Governor. The candidate from the former ruling party was Atiku Abubakar, a former vice president, a very wealthy man. His wealth came from his holdings in the ports, which he helped privatize when he was vice president.
For the first time, Nigeria had adopted electronic transmission of voting from the polling units. That meant that the polling unit voting sheets could be viewed in real time on a website.
As the results started coming in, the country was electrified. Tens of thousands of votes were coming in for Peter Obi. Then hundreds of thousands of votes started coming in. Then a million votes came in and another million.
The senatorial election results started coming in, and the Labour Party was winning seats. An unknown party with no previous Governor or Senate seat was sweeping seats across wide swathes of the country.
But there was no way of knowing who won. Even though the Nigerian Electoral Body had agreed to electronic transmission of polling unit results, the senators and political establishment had blocked the electronic transfer of actual votes. They wanted it still written on paper, for reasons we can guess at.
With 170,000 thousand polling units, it was going to take a long time to count the results.
But across social media, videos and photos were spreading of the Labour Party winning polling unit after polling unit, people yelling in happiness as the party won. Even in the rural areas, where the politicians had claimed they had absolute control, the party was winning unit after unit.
But other disturbing videos were also coming out - of polling units destroyed, and people threatening to hurt anyone who voted for the Labour party.
Social Media waited for the election commission to announce the results. People tried to tally the results online, but with 170,000 PDFs in a completely unstructured format, it was close to impossible.
Then INEC started announcing the state results, over a multiple day counting marathon. At the end, the result was announced:
The Obidients had won in the capital city and had defeated the ruling party and their candidate in Lagos - the state they had ruled for the last 16 years. But according to the official tally, they had lost in the country.
But even as the results were being announced, people on social media were discovering that if they manually added all the results from the servers of the electoral umpire together, the total did not add up to the votes announced. They showed examples from Rivers State, where just a few polling units added together exceeded the votes announced by the electoral umpire. People cried foul.
The amended electoral rules required the parties to challenge election results within 21 days after they were announced. But to file, evidence was needed. The only evidence about how the election really went was spread out across 170,000 photographs of polling unit results. There was no digital version of the results, just photos.
The clock was ticking, and immediately various Obidient groups sprung up to figure out how to extract the data out of the photos. I was in one of the groups, and we decided to try various things.
The first thing was OCR. The photos were all snapped in many different ways, with hardly any structure. Each party result had a number beside it. The photo angles were different. Many sheets were blurry or had camera flash on them.
All the open source OCR software gave bad results. The best result came from Amazon Rekognition, but it was still not good enough - it would occasionally change the scores, and that was simply not going to work.
After experimenting with OCR for about a day, we gave up. We had about 8 days left to go.
We had a brainstorming meeting, and decided to try a new approach. We would simply ask the Obidients to help us do the conversion. If hundreds of Obidients did the transcription, it would go fast.
So we quickly designed out a website:
And then started coding. The frontend was in React, and the backend in PHP Laravel.
A couple of days later, the app was done. A simple site that showed a picture of a polling unit sheet and asked people to enter the votes they saw in some textfields. Then the values would be saved in the database.
Within minutes, I was getting replies from the Obidients. People were jumping on the site, and the first results started going up. The progress bar started moving, slowly at first, and then faster and faster. We went from transcribing one result every minute to transcribing 1 every 10 seconds, and soon we were transcribing at 1 sheet per second.
Traffic grew on the site, and soon our completely unoptimized backend was struggling to catch up. But we were moving forward. We quickly grew to be transcribing 20,000 sheets per day.
The site had a results page that was updating the results live as the sheets were transcribing. The results were growing, and by the time we had counted 6 million votes, the Obidients were clearly in the lead. We kept transcribing, and by the time we had reached 50% of the count - 10 million votes - Peter Obi was strongly in the lead.
I tweeted that out, and all hell broke loose. Suddenly, out of nowhere thousands of spam twitter accounts came out of nowhere, attacking the effort. Threats, attacks of all kinds hit us.
Then the bots came. Thousands of entries started on the site - all entering huge numbers for the ruling party. Different IP addresses, different proxies, all entering fake numbers.
When we started the project, we had a plan. We would first transcribe all 170,000 polling unit results, then we would do a second pass of all the results again as a validation step. If the same numbers were entered twice, then it was likely that the entered numbers were correct. But with the bots entering fake numbers, we now had a new battle to fight.
We immediately enabled captcha, and that slowed down the bots a bit. Then we quickly implemented a check to see if anybody would enter weirdly large numbers, we would ignore their entries moving forward. Then we started showing some results we knew to the bots - if they entered wrong numbers, we would stop accepting the results.
Whoever was behind the bots kept adapting and counteracting what we were doing. They went from using a script to using what felt like hundreds of humans. They went from entering absurdly large numbers to entering plausible numbers. They started entering some correct and some wrong numbers.
But the combination of techniques and the large number of Obidients also working meant that we were also getting a huge number of correct entries.
It seemed the counter-parties realized that they would not win on technology, so they started a new campaign. Hundreds of accounts that claimed to be Obidients suddenly popped up, saying that we were working for the ruling party, and that the work we were doing was designed to prove that the Obidients had lost the election. Every single post I made would have tens of those accounts replying.
And they doubled down - they created a fake screenshot showing that the ruling party had won on our site, and started spreading that. A current Government minister even tweeted this out, and a badly written article hurriedly appeared on a major local newspaper.
Their technique worked. The Obidients started doubting. Prominent Obidient accounts started threads questioning if we were working for the Government.
Meanwhile, we had completed transcribing 150,000 polling unit sheets, and we needed to move to the validation phase where we would correct all the damage the bots had done.
But the damage had been done. The crowd we had pulled to do the work did not trust us anymore. We did not have anyone anymore to help us validate the entries. Work started, but moved very slowly - less than 2000 entries validated in a day. It would take us 3 months to finish at this rate.
Was our project going to fail? If we did not announce results, the Obidients would be sure that we were working for the Government. And the Government already saw us as enemies. How could we solve this?
I started looking through the data. We had 800,000 submissions in our database for 170,000 polling units. I was randomly sampling, and I noticed that a huge number of entries were correct. And strangely enough, the ones with the wrong entries had lots and lots of wrong entries. While the vast majority, which only had one entry, were mostly correct.
I tested around a bit, and then I realized. We had a bug in the code. When you opened the website for the first time, it was buggy - it was not returning a totally random entry the way it was supposed to. It had a huge tendency to return from a small set of entries. But subsequent ones were now random.
That meant that every time the website was fully refreshed, the first polling unit entered was one that probably already had hundreds of entries. But if you kept working, you would now be working on new units.
And I realized what could have happened - whoever was controlling the bots must have told them to refresh after every entry. Probably they figured out that it would make it harder for us to detect. But then they ended up entering all the wrong values mostly for a small set of units that we could easily clean up. Up to 90% of our data was perfectly clean.
We quickly stopped all entries, and start crunching the results. A few hours of heavy server lifting, and we were done. We had transcribed 170,000 polling unit sheets to CSV format in 5 days with a large group of volunteers.
We shared the results with the team for them to submit as part of their evidence. And we were done.
We published the results in spreadsheets here. https://drive.google.com/drive/folders/173oHgms6wYy5WKz_i3Lhl5mXcmobCWHz?usp=sharing.
Peter Obi filed his petition on the last day. And I was happy to see some familiar things in the filing:
Now we wait to see how the tribunal will decide.
Email me on markessien@gmail.com or follow on twitter: twitter.com/markessien.
...
Read the original on markessien.com »
* Block Inc., formerly known as Square Inc., is a $44 billion market cap company that claims to have developed a “frictionless” and “magical” financial technology with a mission to empower the “unbanked” and the “underbanked”.
* Our 2-year investigation has concluded that Block has systematically taken advantage of the demographics it claims to be helping. The “magic” behind Block’s business has not been disruptive innovation, but rather the company’s willingness to facilitate fraud against consumers and the government, avoid regulation, dress up predatory loans and fees as revolutionary technology, and mislead investors with inflated metrics.
* Our research involved dozens of interviews with former employees, partners, and industry experts, extensive review of regulatory and litigation records, and FOIA and public records requests.
* Most analysts are excited about the post-pandemic surge of Block’s Cash App platform, with expectations that its 51 million monthly transacting active users and low customer acquisition costs will drive high margin growth and serve as a future platform to offer new products.
* Our research indicates, however, that Block has wildly overstated its genuine user counts and has understated its customer acquisition costs. Former employees estimated that 40%-75% of accounts they reviewed were fake, involved in fraud, or were additional accounts tied to a single individual.
* Core to the issue is that Block has embraced one traditionally very “underbanked” segment of the population: criminals. The company’s “Wild West” approach to compliance made it easy for bad actors to mass-create accounts for identity fraud and other scams, then extract stolen funds quickly.
* Even when users were caught engaging in fraud or other prohibited activity, Block blacklisted the account without banning the user. A former customer service rep shared screenshots showing how blacklisted accounts were regularly associated with dozens or hundreds of other active accounts suspected of fraud. This phenomenon of allowing blacklisted users was so common that rappers bragged about it in hip hop songs.
* Block obfuscates how many individuals are on the Cash App platform by reporting misleading “transacting active” metrics filled with fake and duplicate accounts. Block can and should clarify to investors an estimate on how many unique people actually use Cash App.
* CEO Jack Dorsey has publicly touted how Cash App is mentioned in hundreds of hip hop songs as evidence of its mainstream appeal. A review of those songs show that the artists are not generally rapping about Cash App’s smooth user interface—many describe using it to scam, traffic drugs or even pay for murder. [See our compilation video on this here]
* “I paid them hitters through Cash App”— Block paid to promote a video for a song called “Cash App” which described paying contract killers through the app. The song’s artist was later arrested for attempted murder.
* Cash App was also cited “by far” as the top app used in reported U.S. sex trafficking, according to a leading non-profit organization. Multiple Department of Justice complaints outline how Cash App has been used to facilitate sex trafficking, including sex trafficking of minors.
* There is even a gang named after Cash App: In 2021, Baltimore authorities charged members of the “Cash App” gang with distribution of fentanyl in a West Baltimore neighborhood, according to news reports and criminal records.
* Beyond facilitating payments for criminal activity, the platform has been overrun with scam accounts and fake users, according to numerous interviews with former employees.
* Examples of obvious distortions abound: “Jack Dorsey” has multiple fake accounts, including some that appear aimed at scamming Cash App users. “Elon Musk” and “Donald Trump” have dozens.
* To test this, we turned our accounts into “Donald Trump” and “Elon Musk” and were easily able to send and receive money. We ordered a Cash Card under our obviously fake Donald Trump account, checking to see if Cash App’s compliance would take issue—the card promptly arrived in the mail.
* Former employees described how Cash App suppressed internal concerns and ignored user pleas for help as criminal activity and fraud ran rampant on its platform. This appeared to be an effort to grow Cash App’s user base by strategically disregarding Anti Money Laundering (AML) rules.
* The COVID-19 pandemic and nationwide lockdowns posed an existential threat to Block’s key driver of gross profit at the time, merchant services.
* In this environment, amid Cash App’s anti-compliance free-for-all, the app facilitated a massive wave of government COVID-relief payments. CEO Jack Dorsey Tweeted that users could get government payments through Cash App “immediately” with “no bank account needed” due to its frictionless technology.
* Within weeks of Cash App accounts receiving their first government payments, states were seeking to claw back suspected fraudulent payments—Washington State wanted more than $200 million back from payment processors while Arizona sought to recover $500 million, former employees told us.
* Once again, the signs were hard to miss. Rapper “Nuke Bizzle”, made a popular music video about committing COVID fraud. Several weeks later, he was arrested and eventually convicted for committing COVID fraud. The only payment provider mentioned in the indictment was Cash App, which was used to facilitate the fraudulent payments.
* We filed public records requests to learn more about Block’s role in facilitating pandemic relief fraud and received answers from several states.
* Massachusetts sought to claw back over 69,000 unemployment payments from Cash App accounts just four months into the pandemic. Suspect transactions at Cash App’s partner bank were disproportionate, exceeding major banks like JP Morgan and Wells Fargo, despite the latter banks having 4x-5x as many deposit accounts.
* In Ohio, Cash App’s partner bank had 8x the suspect pandemic-related unemployment payments as the bank that processed the most unemployment claims in the state, even though the latter bank processed 2x the claims as Cash App’s, according to data we obtained via a public records request.
* The data shows that compared to its Ohio competitor, Cash App’s partner bank had nearly 10x the number of applicants who applied for benefits through a bank account used by another claimant — a clear red flag of fraud.
* Block had obvious compliance lapses that made fraud easy, such as permitting single accounts to receive unemployment payments on behalf of multiple individuals from various states and ineffective address verification.
* In an apparent effort to preserve its growth engine, Cash App ignored internal employee concerns, along with warnings from the Secret Service, the U.S. Department of Labor OIG, FinCEN, and State Regulators which all specifically flagged the issue of multiple COVID relief payments going to the same account as an obvious sign of fraud.
* Block reported a pandemic surge in user counts and revenue, ignoring the contribution of widespread fraudulent accounts and payments. The new business provided a sharp one-time increase to Block’s stock, which rose 639% in 18 months during the pandemic.
* As Block’s stock soared on the back of its facilitation of fraud, co-founders Jack Dorsey and James McKelvey collectively sold over $1 billion of stock during the pandemic. Other executives, including CFO Amrita Ahuja and the lead manager for Cash App Brian Grassadonia, also dumped millions of dollars in stock.
* With its influx of pandemic Cash App users, our research shows Block has quietly fueled its profitability by avoiding a key banking regulation meant to protect merchants. “Interchange fees” are fees charged to merchants for accepting use of various payment cards.
* Congress passed a law that legally caps “interchange fees” charged by large banks that have over $10 billion in assets. Despite having $31 billion in assets, Block avoids these regulations by routing payments through a small bank and gouging merchants with elevated fees.
* Block includes only a single vague reference in its filings acknowledging it earns revenue from “interchange fees”. It has never revealed the full economics of this category, yet roughly one-third of Cash App’s revenue came from this opaque source, according to a 2022 Credit Suisse research report.
* Competitor PayPal has disclosed it is under investigation by both the SEC and the CFPB over its similar use of a small bank to avoid “interchange fee” caps. A Freedom of Information Act (FOIA) request we filed with the SEC indicates that Block may be part of a similar investigation.
* Block’s $29 billion deal to acquire ‘buy now pay later’ (BNPL) service Afterpay closed in January 2022. Afterpay has been celebrated by Block as a major financial innovation, allowing users to buy things like a pair of shoes or a t-shirt and pay over time, only incurring massive fees if subsequent payments are late.
* Afterpay was designed in a way that avoided responsible lending rules in its native Australia, extending a form of credit to users without income verification or credit checks. The service doesn’t technically charge “interest”, but late fees can reach APR equivalents as high as 289%.
* The acquisition is flopping. In 2022, the year Afterpay was acquired, it lost $357 million, accelerating from 2021 losses of $184 million.
* Fitch Ratings reported that Afterpay delinquencies through March 2022 had more than doubled to 4.1%, from 1.7% in June 2021 (just prior to the announced acquisition). Total processing volume declined -4.8% from the previous year.
* Block regularly hypes other mundane or predatory sources of revenue as technological breakthroughs. Roughly 31% of Cash App’s revenue comes from “instant deposit” which Block says it pioneered and works as if by “magic”. Every other major competitor we checked provides a similar service at comparable or better rates.
* On a purely fundamental basis, even before factoring in the findings of our investigation, we see downside of between 65% to 75% in Block shares. Block reported a 1% year over year revenue decline and a GAAP loss of $540.7 million in 2022. Analysts have future expectations of GAAP unprofitability and the company has warned it may not be profitable.
* Despite this, Block is valued like a profitable growth company at (i) an EV/EBITDA multiple of 60x; (ii) a forward 2023 “adjusted” earnings multiple of 41x; and (iii) a price to tangible book ratio of 13.1x, all wildly out of line with fintech peers.
* Despite its current rich multiples, Block is also facing threats from key competitors like Zelle, Venmo/Paypal and fast-growing payment solutions from smartphone powerhouses like Apple and Google. Apple has grown Apple Pay activations from 20% in 2017 to over 70% in 2022 and now leads in digital wallet market share.
* In sum, we think Block has misled investors on key metrics, and embraced predatory offerings and compliance worst-practices in order to fuel growth and profit from facilitation of fraud against consumers and the government.
* We also believe Jack Dorsey has built an empire—and amassed a $5 billion personal fortune—professing to care deeply about the demographics he is taking advantage of. With Dorsey and top executives already having sold over $1 billion in equity on Block’s meteoric pandemic run higher, they have ensured they will be fine, regardless of the outcome for everyone else.
Initial Disclosure: After extensive research, we have taken a short position in shares of Block, Inc. (NYSE: SQ). This report represents our opinion, and we encourage every reader to do their own due diligence. Please see our full disclaimer at the bottom of the report.
Block, Inc. (SQ), founded by entrepreneur Jack Dorsey, is a Silicon Valley darling, offering payment and mobile banking services for merchants and consumers.
The company, then named Square, began operations in 2009 and emerged with a disruptive idea: a tiny card reader that could plug into a smartphone’s headphone jack to easily enable artists and vendors to take credit card payments.
From there, the company developed tablet-style point-of-sale systems, a market that grew immensely, resulting in strong competition including from companies like Toast and Clover. Once the point-of-sale market adapted to Block’s disruption, the company looked elsewhere to keep its growth story alive.
In 2013, a month following PayPal’s acquisition of Venmo, Block launched Square Cash, later rebranded Cash App. It aimed to compete with Venmo by providing financial services to consumers, starting with a peer-to-peer mobile app where users could send and receive money.
In 2014, following the surge of the peer to peer lending market, Block began offering short-term loans to its merchant base, with Block receiving a percentage of every transaction until the loans were repaid. [Pg. 5] [1,2,3]
In 2017, Block expanded toward more traditional banking by introducing the “Cash Card,” a prepaid debit card allowing users to transact outside of their virtual Cash App wallet. [Pg. 10]
In 2018, following bitcoin’s spike in price and popularity, Cash App allowed users to move funds in their Cash App wallet into Bitcoin.
By 2019, following Robinhood’s surge in popularity, Block also began offering free stock trading. [Pg. 14]
Prior to 2020, the merchant services side of Block’s business drove the company’s profitability. As of the end of 2019, merchant services accounted for $1.39 billion in gross profit, compared to the consumer-facing Cash App, which accounted for only $457.6 million of gross profit.[1]
That changed during the pandemic, as many merchant businesses locked down and individuals activated millions of Cash App accounts to receive government stimulus and unemployment payments.
By the end of 2019, Cash App had 24 million monthly active users, according to the company’s Q4 letter to shareholders. [Pg. 2] By the end of 2020, Cash App reported 36 million monthly actives, which has since grown to 51 million. [Pg. 2]
The explosion of user growth resulted in higher gross profit. By the end of 2020, Cash App gross profit reached $1.2 billion, a 170% growth rate from the prior year, compared with merchant services gross profit of $1.5 billion, an 8% growth rate from the prior year.[2]
During the company’s Q3 earnings call in November 2021, Jack Dorsey explained how Cash App is an ideal platform to introduce new services to customers because of its low customer acquisition costs, owing to its viral appeal:
“So, we have these incredible viral loop and network effects in peer-to-peer, and now we get to look forward towards being more of a commerce front end.”
In September 2022, Block CFO Amrita Ahuja cited the company’s purchase of buy-now-pay-later company Afterpay as an example of this strategy, saying it created “an incredible opportunity for us, particularly when you think about leveraging that capability across Cash App 80 million annual actives.”[3]
Investors are now betting that Cash App’s growing millions of users will create a ready market for Block’s future high-margin financial products.
“Block expects Cash App Commerce to be one of Cash App’s primary gross profit growth drivers in the coming years and is investing accordingly,” Credit Suisse said after a Q3 2022 meeting with Block.
Analysts have highlighted the reliance on Cash App as the key driver of Block’s stock going forward.
“In our view, performance of the Cash App business remains the most important driver of the stock,” Bank of America said in an October 2022 report.
As of March 23rd, 2023, 23 sell-side analysts had a “Buy” rating on Block shares, 5 had a “Hold” rating, and only 2 had a “Sell” rating, according to MarketBeat.
The company’s promise has drawn in popular investors like Cathie Wood, whose ARK Funds hold a combined $651.5 million in Block stock, comprising just over 5% of the manager’s holdings, according to Cathie’s Ark, a site that tracks ARK’s holdings.
Block’s revenue declined ~1% in 2022 versus the prior year. [Pg. 69] On a GAAP basis, Block posted a net loss of $540.7 million for 2022. Analysts expect Block will lose $208 million in 2023, according to FactSet estimates. Block’s 2022 annual report warned:
“We have generated significant net losses in the past, and we intend to continue to invest in our business. Thus, we may not be able to maintain profitability.” [Pg. 25]
Cash App, which analysts have said is the most important driver of the stock, has demonstrated signs of stagnation with slowing inflows and account growth.
Despite its revenue slowdown, current unprofitability, its warning of future unprofitability, and signs of stagnation at Cash App, investors have awarded Block valuation multiples that price in an expectation of rapid growth. The company trades at an EV/EBITDA multiple of 60x and a 2023 forward P/E ratio of 40x on “adjusted” earnings, according to FactSet.
By comparison, Block competitor Paypal trades at an EV/EBITDA multiple of 16.6x, and 15.1x adjusted 2023 earnings, suggesting 62%-72% downside for Block were it to trade in line with its peer.
On a tangible book basis, many fintech competitors such as Affirm, Robinhood, SoFi and Upstart trade between 1.6x to 2.1x, whereas Block trades at ~13x tangible book. Even Paypal, which has grown revenue and generated a GAAP profit every year since re-emerging as a public company, trades at a 25% discount to Block on this basis. A re-rating closer to the peer average would represent 77.5% downside for Block.
To make up for these fundamental realities, Block has extensively relied on non-GAAP adjustments to report growth despite weakening metrics.
Block transformed its $540.7 million GAAP loss for 2022 into a $613 million non-GAAP profit, by adjusting out costs, including over $1 billion in 2022 share-based compensation, according to financial information from the company’s website.[4]
Block’s reliance on non-GAAP adjustments to report profit has increased substantially over time.
We are entering a period where the endless hype and unrealistic valuations of past years are beginning to face the financial reality of higher interest rates.
We expect this macro headwind, combined with the other issues outlined below, will result in the contraction of Block’s exaggerated claims of profitability and generous valuation multiples.
Founder Jack Dorsey has described Block’s business as having a “purpose of economic empowerment.”
The company says it has chosen to serve the “unbanked” and “underbanked”, segments of the population that do not engage in traditional banking due to weak or non-existent credit scores, distrust of banks and high fees.
In 2017, Dorsey described how Block planned to continue servicing the underbanked through Cash App:
“So, from a high level, we want to make sure that we continue to build services for an underserved market. That has been what has really tied the company together for the past — close to 9 years now.”[5]
The effects of that strategy are apparent. A September 2022 Pew Research Center survey shows that Cash App has targeted low-income and minority consumers.
Block says it provides uniquely easy access to sending and receiving funds, by removing friction from the system and “adding some magic”:[6]
“Our focus is really observing what our customers are doing,” Dorsey said of the company’s approach in 2018, “and then taking as much friction out of that as possible while adding some magic at the same time.”[7]
Cash App’s frictionless approach lets users join with just an email or a phone number.
With its principled mission and easy to use Cash App payment platform, Block has gained a reputation as an innovator and one of the most well-known publicly traded fintech companies.
By contrast, what we found is that the company’s payment system does not seem to offer a discernible edge over its key competitors like PayPal/Venmo, Zelle, or Apple. Rather, it seems to have simply embraced non-compliance as a tactic to grow its user base.
Our research shows that Block has embraced a traditionally very underbanked segment of the population: criminals.
Cash App’s embrace of non-compliance begins by making it easy for users to get on the platform, easy for them to get back on the platform if their accounts are closed, and easy to remain anonymous or operate under blatantly false identities.
As one former said about signing up for Cash App:
“It’s wide open. And if I was a criminal, I would have done it.”
Another former compliance employee of a Cash App partnership told us, “every criminal has a Square Cash App account.”
There is even a gang named after Cash App: In 2021, Baltimore authorities arrested members of the “Cash App” gang, who were charged with distribution of fentanyl and cocaine in a West Baltimore neighborhood, according to a Baltimore news report, and criminal records.
Beyond the gang named after Cash App, numerous department of Justice indictments detail how Cash App is used by gangs, including the notorious Sinaloa cartel, to distribute drugs like fentanyl and methamphetamine. [1,2,3]
In one example, a criminal complaint against an alleged meth distribution ring describes how Cash App is commonly used by gangs to transfer illicit drug proceeds:
In May 2020, Block CEO Jack Dorsey spoke at a JPMorgan investor conference about how Cash App was making its way into popular culture through thousands of mentions in hip hop music:
“We have a very mainstream customer for Cash App. And evidence of this is — I talked about this on the call, maybe on the stage before, but the number of hip-hop songs that include the phrase Cash App or even named Cash App is pretty incredible. I think it’s over 1,000 or 2,000 right now.”[8]
At JPMorgan’s 2021 conference, Dorsey again told investors about the large number of songs named after Cash App and described how music had become a way to share with others how valuable the app is to them personally, providing them with “so much utility.”[9]
A review of songs mentioning Cash App shows that the artists are not generally rapping about Cash App’s smooth user interface and robust software integration toolkit.
Instead, lyrics describe how easy it is to move money through Cash App to facilitate fraud, traffic drugs, or even pay for murder.
[Listen to a compilation of songs mentioning Cash App here]
Block promoted the video for 22Gz’s song “Cash App” which described a turf war in which the artist pays hitmen through Cash App to murder his opposition, then stuffs their bodies in trash bags. The video opens with the artist showing his Cash App as he makes a ‘throat-slitting’ motion.
...
Read the original on hindenburgresearch.com »
Aperiodic tiling, in which shapes can fit together to create infinite patterns that never repeat, has fascinated mathematicians for decades, but until now no one knew if it could be done with just one shape
Aperiodic tiling, in which shapes can fit together to create infinite patterns that never repeat, has fascinated mathematicians for decades, but until now no one knew if it could be done with just one shape
This single shape produces a pattern that never repeats
Mathematicians have discovered a single shape that can be used to cover a surface completely without ever creating a repeating pattern. The long-sought shape is surprisingly simple but has taken decades to uncover — and could find uses in everything from material science to decorating.
Simple shapes such as squares and equilateral triangles can tile, or snugly cover a surface without gaps, in a repeating pattern that will be familiar to anyone who has stared at a bathroom wall. Mathematicians are interested in …
...
Read the original on www.newscientist.com »
Skip to content
Sign up
Reference implementation of the Transformer architecture optimized for Apple Neural Engine (ANE)
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Use Git or checkout with SVN using the web URL.
Work fast with our official CLI. Learn more.
Please sign in
to use Codespaces.
If nothing happens, download GitHub Desktop and try again.
If nothing happens, download GitHub Desktop and try again.
If nothing happens, download Xcode and try again.
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
Permalink
Reference implementation of the Transformer architecture optimized for Apple Neural Engine (ANE)
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
...
Read the original on github.com »
Heya. Sorry for not writing for so long. I’ll make up for it with 3000 pages here.
I’m just hopping right now. That’s kinda the only way to get me to blog anymore.
I’ve rewritten this post so many times. It’s about AI. But AI is changing so fast that the post is out of date within a few days. So screw it. I’m busting this version out in one sitting.
There is something legendary and historic happening in software engineering, right now as we speak, and yet most of you don’t realize at all how big it is.
LLMs aren’t just the biggest change since social, mobile, or cloud–they’re the biggest thing since the World Wide Web. And on the coding front, they’re the biggest thing since IDEs and Stack Overflow, and may well eclipse them both.
But most of the engineers I personally know are sort of squinting at it and thinking, “Is this another crypto?” Even the devs at Sourcegraph are skeptical. I mean, what engineer isn’t. Being skeptical is a survival skill.
Remember I told you how my Amazon shares would have been worth $130 million USD today if I hadn’t been such a skeptic about how big Amazon was going to get, and unloaded them all back in 2004-ish. Right? I told you about that? I’m sure I mentioned it once or twice. Not that I am bitter. No.
But did I ever tell you about the time AWS was just a demo on some engineer’s laptop? No? Well it was Ruben Ortega and Al Vermeulen. They were walking around the eng department at Amazon, showing their “web service” demo to anyone who’d watch it. This was back in maybe… 2003? Ish? They showed us how you could make a service call over the web, like by hitting a URL and sending the right query parameters.
Well lo and behold we were skeptical. Why the hell would you make a service call over the web? That’s not what it was even designed for! Not to mention, it obviously wouldn’t perform as well as CORBA (Amazon’s stupid-ass RPC system at the time). The whole thing just didn’t make any sense to us.
We were seeing the first little flecks of lava from what would become a trillion-dollar volcano of money called AWS and Cloud Computing.
But a lot of us were skeptical. To most of us, those little lava flecks looked like fireflies.
I could tell you a LOT of stories like the web-services one. Great big shit always starts life as a demo.
What about chatting with people in a browser? Doesn’t matter whether you’re using Facebook, Google Chat, LinkedIn, or just chatting with a customer service agent: if you’re having a conversation with someone in a browser, all that shit started life as a teeny demo of 2 engineers sending messages back and forth over a “hanging GET” channel back in 2005. Entire industries were built on that one little channel, and it wasn’t even very good.
What about Kubernetes? I remember seeing a demo of that early on, on Brendan Burns’ work laptop, when it was called mini-Borg. Entire industries are being built on Kubernetes, and it’s not even very good either. 😉 Or look at Docker! Something as innocuous as linux cgroups, a little process-isolation manager, became the technical foundation for containers, which now utterly pervade our industry.
If you can build something as big as Amazon Web Services with a stack based on a simple service call, or whole social networks and customer service suites based on simple browser-to-browser communication, or a robust way of delivering and managing software based on a little process isolation code, then just imagine how big a thing you could build — bear with me here — if you had the goddamn Singularity as your starting point?
I mean, I joke, but… I mean… Right? I’m guessing you prolly missed it in OpenAI’s 98-page GPT-4 technical report, but large models are apparently already prone to discovering that “power-seeking” is an effective strategy for increasing their own robustness. Open the PDF and search for “power-seeking” for a fun and totally 100% non-scary read.
You can build truly massive things by building upon little technical breakthroughs.
And folks, this technical breakthrough? It ain’t little.
If you’re not pant-peeingly excited and worried about this yet, well… you should be.
We did an internal poll at Sourcegraph: Do you have positive sentiment or negative sentiment about LLMs for coding? Options were Positive, Negative, and Meh. And lo, it was about ⅔ Meh or Negative (i.e., Skeptics), which I suspect is fairly representative of the whole industry.
I asked around, and even as of a couple weeks ago, some devs questioned whether ChatGPT could even write working code, let alone write a full program by simply by telling it to write it.
So here I am, talking about money volcanoes, and my coworkers have formed a huge whirling meh-nado. Which natural disaster should you believe?
Well I mean, I guess a demo is worth a thousand mehs. Let’s try it out.
Let’s have ChatGPT write some Emacs-Lisp code. I’m picking emacs-lisp because it’s a corner case language, bit of a stress test for the LLM, and because it’s easy for me to try it out interactively.
OK. I just typed this prompt into ChatGPT:
> Write an interactive emacs-lisp function that pops to a new buffer, prints out the first paragraph of “A tale of two cities”, and changes all words with ‘i’ in them red. Just print the code without explanation.
Here’s the code it spat out, if you can’t read the screenshot:
(defun display-tale-of-two-cities ()
(interactive)
(let ((text “It was the best of times, it was the worst of times, it was the age of wisdom,
it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity,
it was the season of Light, it was the season of Darkness, it was the spring of hope, it was
the winter of despair, we had everything before us, we had nothing before us, we were all
going direct to Heaven, we were all going direct the other way — in short, the period was so
far like the present period, that some of its noisiest authorities insisted on its being
received, for good or for evil, in the superlative degree of comparison only.“))
(pop-to-buffer “*A Tale of Two Cities*“)
(erase-buffer)
(insert text)
(goto-char (point-min))
(while (re-search-forward “\\b\\w*\\i\\w*\\b” nil t)
(add-text-properties
(match-beginning 0) (match-end 0)
’(face (:foreground “red”))))))
I copied this code directly into my Emacs session and ran it, and it did exactly what I asked it to do:
As you can see from the screenshot, I ran the command and it opened a buffer, printed the requested text, and then turned all the words containing ‘i’ red.
In one shot, ChatGPT has produced completely working code from a sloppy English description! With voice input wired up, I could have written this program by asking my computer to do it.
And not only does it work correctly, the code that it wrote is actually pretty decent emacs-lisp code. It’s not complicated, sure. But it’s good code.
Of course people have done much, much fancier things than this. Someone wrote a product description on a napkin, took a picture, and GPT wrote a working web app that implements the product description on the napkin in the picture. The amount of power here is honestly unknown; it’s more like a cavern that we haven’t fully explored. And it just gets deeper as the LLMs get bigger.
I mean, this stuff is unbelievably powerful. And yet I am persistently met with a mixture of disbelief and pearl-clutching. Argh, the pearl-clutching! Don’t even get me started on the pearl-clutching. Oh look, now you’ve got me started.
Okay, you asked for it.
One of the craziest damned things I hear devs say about LLM-based coding help is that they can’t “trust” the code that it writes, because it “might have bugs in it”.
Can you trust code you yeeted over from Stack Overflow? NO!
Can you trust code you copied from somewhere else in your code base? NO!
Can you trust code you just now wrote carefully by hand, yourself? NOOOO!
All you crazy MFs are completely overlooking the fact that software engineering exists as a discipline because you cannot EVER under any circumstances TRUST CODE. That’s why we have reviewers. And linters. And debuggers. And unit tests. And integration tests. And staging environments. And runbooks. And all of goddamned Operational Excellence. And security checkers, and compliance scanners, and on, and on and on!
So the next one of you to complain that “you can’t trust LLM code” gets a little badge that says “Welcome to engineering motherfucker”. You’ve finally learned the secret of the trade: Don’t. Trust. Anything!
Peeps, let’s do some really simple back-of-envelope math. Trust me, it won’t be difficult math.
* You get the LLM to draft some code for you that’s 80% complete/correct.
* You tweak the last 20% by hand.
How much of a productivity increase is that? Well jeepers, if you’re only doing 1/5th the work, then you are… punches buttons on calculator watch… five times as productive. 😲
When was the last time you got a 5x productivity boost from anything that didn’t involve some sort of chemicals?
I’m serious. I just don’t get people. How can you not appreciate the historic change happening right now?
OK time to get concrete. I’m already on page 7, and my last attempt at this blog ran 25+ pages and languished for weeks.
OK sooooo… this is the part that went on for 20 pages before, so let’s just make it reeeeeal simple. One paragraph.
Here is everything you need to know about the history of LLMs, for our purposes today:
Congrats, you’re all caught up on the history of LLMs. Go watch this amazing video for how to implement it in Python.
OK now we can talk coding assistants. They’re just a thing that sits in your IDE and they talk to the LLM for you.
Depending on the particular assistant, they can read and explain code, document code, write code, autocomplete it, diagnose issues, and even perform arbitrary IDE tasks through “agents” that give the LLM robotic powers, including the ability to wield and target laser guns, if someone wants to put in the work. Some assistants also understand your project environment and can answer questions about build targets, branches, your IDE, etc.
So, already pretty cool. Right?
But now they are beginning to be able to perform more complex tasks, such as generating a PR from the diffs on the current branch, including a detailed commit message summarizing the changes.
Some assistants have a conversational/chat interface, too. This kind can do everything a bot like ChatGPT can do, like drafting emails, or answering random questions about the code base or the environment.
I personally prefer a coding assistant with a chat interface. In part because I can type, but also because it makes them a platform. I can build my own workflows. Bonus points if they expose the underlying platform bits with APIs.
I guess the simplest way to think about it would be a sort of “real-time in-IDE Stack Overflow” coupled with a really powerful new set of boilerplate automation tasks.
OK, congrats again — you’re up to speed on what LLM-based coding assistants can do. It’s… pretty much anything. You could hook it up to outbound email and tell it to sell itself. Sky’s the limit. At this point we’re more limited by imagination than by technology.
So! Yeah. Coding assistants. I hope by now you get how powerful they’re going to be. They may take different shapes and forms, but they’re all going to be incredibly badass before very much longer.
Let’s dig a little into how they understand your personal code, and then we’re ready to party. 🎉
LLMs are trained on an absolutely staggering amount of data… but that doesn’t include your code.
There are two basic approaches to making the LLM smarter about your code. The first is to fine-tune (or train) on your code. This is not a business model that has been fully fleshed out yet, but it’s coming. And importantly it’s only part of the picture.
The other way is to bring in a search engine. You can think of it as three related scenarios:
* A raw LLM is like a Harvard CS grad who knows a lot about coding and took a magic mushroom about 4 hours ago, so it’s mostly worn off, but not totally.
* Fine-tuning it on your code base is like having it study your code carefully, which means it will give better answers in general.
* Incorporating a search engine, much like for humans, makes the AI even more effective, because it can answer direct queries very quickly. And importantly, because the search engine can be used to populate the query context.
Meaning, a search engine can be useful twice per query — once when figuring out how to describe and contextualize the query, and again potentially when answering the query.
* Meaning, a search engine can be useful twice per query — once when figuring out how to describe and contextualize the query, and again potentially when answering the query.
You talk to LLMs by sending them an action or query, plus some relevant context. So for instance, if you want it to write a unit test for a function, then you need to pass along that whole function, along with any other relevant code (e.g. test-fixture code) so that it gets the test right.
That context you send over is called the context window, and I think of it as the “cheat sheet” of information that you pass along as part of your query.
And folks, it ain’t much. It’s almost exactly like a 2-sided index card vs your whole textbook, for an exam. They give you between 4k and 32k tokens of 3-4 characters each, so at best, maybe 100k of text, to input into the LLM as context for your query. That 100k cheat sheet is how you tell the LLM about your code.
In an ideal world, you’d just pass your entire code base in with each query. In fact, Jay Hack just tweeted a graph showing how the latest context window size in GPT-4 compares to some popular code bases:
Which is kind of exciting… until you realize that it’s still just incredibly tiny compared to real-world code bases. It’s an index card vs a textbook… just a slightly bigger index card.
That cheat sheet is all you get. That’s how you talk to an LLM. You pass it a cheat sheet.
Which means what goes ON that cheat sheet, as you can probably imagine, is really really important.
And with that, friends, we are finally ready for the punchline, the party, and the demo.
There are, by my last count, approximately 13 hillion frillion jillion LLM-backed coding assistants out there, as of mid-March. But they are all in a desperate race to the bottom, because they’re all using the exact same raw materials: An LLM, your IDE, your code base, and that pesky little context window.
Nobody can differentiate on the LLM; they’re all about the same. And the IDE and your code base are the same. All they can try to differentiate on is their UI and workflows, which they’re all going to copy off each other. Good for you, bad for them.
The punchline, and it’s honestly one of the hardest things to explain, so I’m going the faith-based route today, is that all the winners in the AI space will have data moats.
A “data moat” is, in a nutshell, having access to some data that others do not have access to.
You need a data moat to differentiate yourself in the LLM world.
Why? Because the data moat is how you populate the context window (“cheat sheet”).
If you can’t feed the LLM your whole code base, and you can only show it 100k characters at a time, then you’d better be really goddamn good at fetching the right data to stuff into that 100k-char window. Because that’s the only way to affect the quality of the LLM’s output!
...
Read the original on about.sourcegraph.com »
Starbucks CEO Laxman Narasimhan told employees Thursday that he’ll work a half day every month at one of the coffee giant’s locations.
Narasimhan took the helm on Monday and will lead the company’s shareholder meeting Thursday. He joined Starbucks in October, spending months learning the business. That included 40 hours of barista training and donning the baristas’ iconic green apron.
But he’s not hanging up the apron just yet.
“To keep us close to the culture and our customers, as well as to our challenges and opportunities, I intend to continue working in stores for a half day each month, and I expect each member of the leadership team to also ensure our support centers stay connected and engaged in the realities of our stores for discussion and improvement,” he wrote in a letter to employees Thursday morning.
His pledge comes at a rocky time for the company’s relationship with its baristas. As of Friday, more than 190 company-owned Starbucks locations have voted to unionize, according to National Labor Relations Board data. Workers have cited unsafe working conditions, understaffing and unreliable scheduling as some of the reasons why they’re in favor of a union.
Before joining Starbucks, Narasimhan was chief executive of Reckitt, which owns brands like Lysol and Durex. Previously, he worked at PepsiCo and McKinsey.
...
Read the original on www.cnbc.com »
To add this web app to your iOS home screen tap the share button and select "Add to the Home Screen".
10HN is also available as an iOS App
If you visit 10HN only rarely, check out the the best articles from the past week.
If you like 10HN please leave feedback and share
Visit pancik.com for more.