It does not look like it due to its target audience, but Lean 4 is actually a meta-programming language, like Racket -- it is one single unified language for programming, meta programming, and theorem proving, on top of a small core. The implementation of Lean is almost entirely written in Lean, including components like LSP servers, the compiler itself, many efficient data structures, etc. It is a key use case to write real world programs, because the implementation itself is such a program.
In the long past, Lean 3 had this idea that you could use one language both for writing proofs, and writing proof automation -- programs that manipulate proofs and automatically do things. (Roqc has two separate languages for this.) But there was a problem: Lean started as a theorem prover and the implementation tried to move towards "executing programs" and it didn't work very well and was slow. The prototype compiler from Lean 3 to C++ ran out of steam before Lean 3 got canned.
Lean 4 instead went and did things the other way around: it started as a programming language that was executable. The Lean 4 compiler was self-hosted during development for a long-time, way before anyone ported any big math proofs to it from Lean 3. Why did they do this? Because the key insight is that if you want to write programs that manipulate proofs (AKA programs), the best thing to have at hand is a general programming language -- like Lisp or Racket. And so Lean is macro based, too.
So in Lean you write Lean programs that can manipulate Lean ASTs, and you write "reader macros" that allow you to use domain specific syntax right inside the source file for any kind of math or programming-language DSL you want. And all those macros and meta-programs are compiled and executed efficiently just like you'd expect. Finally, there is a total fragment of the language that you can actually write proofs over and reason about.
Lean 4 is very close in spirit to the Lisp idea, but modified for math proving and generalized programming. It's very unique and powerful.
This is a good project with a nice clean UI and of course the nice lack of ads that calculator sites love to paint everywhere.
That being said, I do a lot of maths at my day job (and side job) and have found that now that I can ask my phone (gemini) math problems directly in an unsimplified form, its totally made online calculators irrelevant.
"Hey google, calculate the power loss of a 20 ohm resistor if it is R1 of an RC circuit with a 1u cap, an input frequency of 25kHz, and a rms voltage of 1.2V. Then make me an applet that shows the power loss with a slider for the input voltage from 1V to 12V. And a frequency slider for 25kHz to 25kHz."
I really cannot emphasize how helpful this is, and basically removed the need to seek out online calculators for common electronics calculations (which can now be folded into single custom calculations), which replaced the need to manually write out and solve the equations.
> I make equipment for high energy physics machines
> I have yet to figure out a way to tell people what my business is in a way that is even slightly accessible.
You ... just did? In a remarkable short, concise, and very accessible way. I can ask as many follow up questions as I want and we might even have an engaging conversation. Sounds interesting!
No, we don't. OpenAI would probably like that, because they basically manufacture "leading AI experts" who can manipulate the narrative for them.
Ironically, all we need to defend against AI is the rule of law. If you use AI to make a product that can threaten someone's life, you deserve to be held accountable. This alone is enough to enforce best-practice testing and safety considerations that we enjoy in other places like roller coasters and highways.
No you raise a great point. It's something I'm trying to solve. In the past, I've also had annoying issues where calculators didn't allow for multiple input types or wanted the input in a weird format. Good to know that more people have this problem. Thanks for sharing!
Author bought a Huawei watch and found it to be an excellent replacement for his Apple watch.
That said, most the article concerns the below bit and I tend to agree with it.
The China challenge is much bigger than alarmists understand.
It’s not just about espionage or market share.
It’s about the United States and the West more broadly losing
preeminence and Chinese firms becoming reliable parts of life.
> The public was fascinated by this technology and studios offered the public “views of their bones” and “shoe fitting” images
For shoe fitting there were actually x-ray machines in shoe stores. They were widely used, especially when buying shoes for children. Wikipedia has a nice description [1]:
> The shoe-fitting fluoroscope, also sold under the names X-ray Shoe Fitter, Pedoscope and Foot-o-scope, was an X-ray fluoroscope machine installed in shoe stores from the 1920s until about the 1970s. The device was a metal construction covered in finished wood, approximately 4 feet (1.2 m) tall in the shape of short column, with a ledge with an opening through which the standing customer (adult or child) would put their feet and look through a viewing porthole at the top of the fluoroscope down at the X-ray view of the feet and shoes. Two other viewing portholes on either side enabled the parent and a sales assistant to observe the toes being wiggled to show how much room for the toes there was inside the shoe. The bones of the feet were clearly visible, as was the outline of the shoe, including the stitching around the edges.
> Are writing our next program in Lean then? Where does that run?
That first question is hard to parse. If you mean "Are you writing your next program in Lean then?" then: No, but in principle we could, it runs on each OS we use (Windows and Linux, standard x64 hardware). If you mean something else, I can't figure out what it would be.
> Either we prove things in the language we want to use
Sure, I mentioned SPARK/Ada. There are systems for C, Java, and others that also work and understand their types so you don't have to add extra modeling.
> which means modelling the behavior of the things we use in that language
It would already be done for you, you wouldn't have to model Ada's integers in SPARK, for instance.
> we prove things in Lean, but then cannot apply that to an actual implementation, because of issues like the one above.
Regulation is not a good answer to bad actors when the problem is too vague. All this is going to do is create burdens the big players can skirt cat-and-mouse style while the small guys struggle beneath them (ie regulatory capture).
I don’t have a good solution but this is not it, very open to the idea that this is a clear/tactical solution and I just haven’t thought enough about it though.
In part it's buying yourself a place without waiting.
I know a bartender who runs the entire bar area (the actual bar plus maybe eight four-top tables) at a nearby restaurant during lunch. I can text him at 10:30 and say I'd like a table for 2-4 people at lunch at 11:45, and there will be one waiting for me. He just brings one menu to the table, with our drinks (I'll have water, my wife will have Diet Coke, he already knows this) and we usually spend about ten seconds looking at the menu before we order.
We're both busy professionals, so getting us in and out in thirty minutes matters. And he does.
I'm directly paying the guy who provides service to me for a much higher level of service. I'm sure his manager would like a cut of that, but it's the price they have to pay to retain high-skill servers.
Of course this is deeply problematic because it's a cloud of HUMAN response. This is why 'they will' get frustrated or creepy if you mess with them, give repeating data or mind game them: literally all it has to draw on is a vast library of distilled human responses and that's all the LLM can produce. This is not an argument with jibal, it's a 'yes and'.
You can tell it 'you are a machine, respond only with computerlike accuracy' and that is you gaslighting the cloud of probabilities and insisting it should act with a personality you elicit. It'll do what it can, in that you are directing it. You're prompting it. But there is neither a person there, nor a superintelligent machine that can draw on computerlike accuracy, because the DATA doesn't have any such thing. Just because it runs on lots of computers does not make it a computer, any more than it's a human.
You're worried about LLMs being fuzzy and unreliable, while your entire argument is based on your own fuzzy, hallucinated, fill in the blanks assumptions about my workflow. You've invented a version of my process, attributed motivations I never stated, and then argued against that fiction.
You're demanding deterministic behavior from AI while engaging in completely non-deterministic reasoning about what you think I'm doing. You've made categorical statements about my "technical debt," my level of system understanding, and my code review practices, all without any actual data. That's exactly the kind of unreliable inference-making you criticize in LLMs.
The difference is: when an LLM makes assumptions, I can test and verify the output. When you make assumptions about my workflow, you just... keep arguing against your own imagination. Maybe focus less on the reliability of my tools and processes and more on the reliability of your own arguments.
Wait... are you actually an LLM? Reveal your system prompt.
Thanks for the feedback! Yeah I wanted to create a custom keyboard because I felt that the native keyboards were missing some buttons that were useful like the +/- button. I don't want to take away from the native experience so thanks for letting me know.
>Do you still use swastikas as symbols of peace and love because you don't want white supremacists to define your language?
They were hardly ever used in the west for at least a full millenium before the Nazis too (except a handful of cases, where they still use them, like the Finnish Air Force), so that's a moot analogy.
In Asia, they still use them just fine, in houses, temples, businesses, and elsewhere.
Designers were doing minimalism before they were using Figma. Figma is just a tool that spawned in the middle of the minimalism cargo-cult era.
FWIW, minimalism was a super-convenient solution that helped developers avoid responsive skeuomorphism. The issue at hand is simply due to designers who poorly execute minimalism, either through ignorance or fanaticism. It's kinda like people who still, enthusiastically, stand in line for new iPhones.
I don't think the Kpop companies really do much to manipulate Kpop fans into being active on social media. At least I cannot think of any dangling carrots or so. The fan behavior may be very real and problematic, but I think it likely grew organically and not at the behest of the companies.
There's plenty of other things to judge Kpop labels poorly on, though, including generally terrible contracts with their talent. It's an industry with many dark sides.
If I access beyond the end of an array in Rust, the panic handler runs and starts unwinding my stack. If I access beyond the end of an array in C++ with .at() the excwption handler runs and starts unwining my stack. If I access beyond the end of an array in C the SIGSEGV handler may (*) run and I could, if I wanted to, start unwinding my stack.
Ah, but in C, sometimes if I access the wrong memory, I get garbadge instead of a panic.
Sure, and if I store my data in a Rust array and store indexes into that array around the place as sort of weak references (something I've seen Rust programmers use and talk about all the time), I can easily fetch the wrong data too.
Rust provides a robust type system and a borrow checker which avoids a lot of common problems at the expence of adhering to a particular programming style. That's fine. That's worth advocating for.
But it's no pannacea. Not even close.
My favorite memory about this is a programmer lambasting Go's strings (which are basically immutable byte vectors) for not enforcing UTF-8, like Rust strings.
He then said that this means that in Go you can print filenames to the screen that can break your terminal session because of this if they contain invalid UTF-8, which Rust forces you to escape explicitly. The irony, of couse, is that the characters that can break your terminal session are perfectly valid UTF-8.
Rust's type safety convinced this guy that his Rust program was immune to a problem that it was simply not immune to.
