I guess I'll say that minicomputer and mainframe implementations of languages like Pascal and FORTRAN and COBOL and even BASIC back in the 1970s were frequently built with interoperability in mind, like you bought all the compilers in one big bundle. (Maybe like gcc or the the llvm-based compiler suite today?) It might have been easier because most of these languages had minimal runtime systems and the science of activation records and language implementation was mostly figured out by 1975 when Scheme came out with closures.
More modern languages have data structures that are similar but different that are a challenge. For instance the list types in Java and Python as they are used in common software are similar in a lot of ways but different. C has arrays in the stdlib but not that kind of expandable list, C developers might write their own or get one out of a library, I guess C++ has std::list but that doesn't have a fast way to get the n-th element of a list. Common Lisp has its own idea of a "list" and Clojure lives in the JVM and can access a Java List just fine but has its own immutable list which has a totally different API than thoses other language (e.g. no nconc!)
In general it is not so hard to access those objects through the 'foreign function API' or whatever you have but you either write stuff in the host language which is built especially to work with the guest language, or you make a wrapper, or you copy the data structures wholesale. It is never going to be trivial.
Similarly a language like Java has garbage collection and Python and Rust have their own forms of reference counting, either way you will either do your own memory management in the guest language or use some APIs to participate in the memory management of the host but it is a hassle.
For a long time the standard architecture for complex systems has been a scripting language + a systems language. Like Lua and C or Python and C or maybe Clojure and Java.
They aren't saying affordable housing isn't needed. Just that the method for making housing affordable shouldn't be trying to make the current housing supply cheaper.
And from this is where you get "rent-control is a terrible idea". Essentially: trying to artificially drive down housing prices in any way is generally inadvisable if you can just build more housing.
Sure that's technically an opinion, but it's one based in facts, and it certainly doesn't have "zero evidence".
Blanket statements like this is the point of many of the above replies, it’s not a true statement with evidence. All rent control does not reduce the number of rentals, “more restrictive rent control”[1] [2] does. These nuances are important in the conversation.
Would be useful if comparable scores for performance are added, perhaps from arena.ai or ARC. I know scores can be imperfect, but it would be nice to be able to easily see what the best model your machine can handle is.
Couldn’t you just feed Claude all the raw, inspect element HTML from the website and have it “decrypt” that?
The entire website is fairly small so this seems feasible.
Usually there’s a big difference between a website’s final code and its source code because of post processing but that seems like a totally solvable Claude problem.
Sure LLMs aren’t great with images, but it’s not like the person who originally wrote the Space Jam website was meticulously messing around with positioning from a reference image to create a circular orbit — they just used the tools they had to create an acceptable result. Claude can do the same.
Perhaps the best method is to re-create, rather than replicate the design.
I'm using source code like it's used when referring to source code vs executables. React doesn't simply spit out HTML, nor the JSX used to write said React code, it outputs a mixture of things that's the optimized HTML/CSS/JS version of the React you wrote. This is akin to source code and the optimized binaries we actually use.
Perhaps the wrong usage of "source code". I probably should've been more precise. Forgive my lack of vocabulary to describe the difference I was referring to.
There were no binaries or packages. You wrote the HTML in notepad or maybe you used some "high speed IDE" with syntax highlighting and some buttons like Dreamweaver and then uploaded it via FTP to whatever server you were hosting it on. No muss, no fuss. It was a glorious time and I miss that internet a lot.
I think you're assuming a pattern existed in 1996 that didn't actually exist until the 2010s.
In 1996 JavaScript was extremely limited; even server side processing was often limited to CGI scripts. There was nothing like React that was in common use at the time. The Space Jam website was almost certainly not dynamically compiled as HTML - it existed and was served as a static set of files.
Even a decade later, React and the frontend-framework sort of thinking wasn't really a big thing. People had started to make lots of things with "DHTML" in the early 2000s where JavaScript was used to make things spicier (pretty animations, some server side loading with AJAX) and still often worked without JS enabled in a pattern called graceful degradation.
What you'd get from "View Source", or "Inspect Element", and what was literally saved on disk of spacejam.com, was almost certainly the same content.
I'm not trying to dispute this though. Although I appreciate the clarity, I am aware of the web's past.
The only point I was trying to make was that this project could be better achieved by an LLM if spacejam.com's HTML is supplied.
For why you'd want to do this rather than simply use the original code is up to the developer, but I'd expect a common reason to be the ease of modern frameworks. Some justifications for making Claude create the same code again in a different framework include:
- Using <script> tags is bad practice in a lot of modern frameworks, and it's better to just translate to React and run your logic directly within components.
- Perhaps you're using TailwindCSS, in which case it's a good idea to port over all the original CSS so you can have unified codebase.
- Hosting on modern frameworks is often conveinent.
- Sometimes (although maybe not for a website this small) the source code with a framework is less verbose.
You probably misunderstood me because I paraphrased "raw" HTML several times throughout my comments in this thread before I actually read the page source and realized it was the original source code.
I think that the reason why everyone is acting surprised about your suggestion is that the target wasn’t to obtain the page in some higher level framework or anything. The HTML of the page was what the author wanted Claude to output. Would he used source HTML as an input, there would be nothing for Claude to do. Different exercise.
So imagine whatever Rust has with C but with many other languages.
reply