a2code

I did not try Clojure so I cannot comment on how well implemented the features you quote are, when compared to CL. All I can say is that CL also provides much of the same functionality with its standard, cl-async, lparallel, parenscript, while (im)mutability is a matter of preference (IMO correct decision by CL) rather than dominance. The way I see it, is that CL is superior (opinion) due to reader macros and native compilation, rather than bytecode JVM.

I have two tech q about partsbox. Why Clojure? Why not CL (lack of saas related-features)?

> The most impressive thing humans can do is to think. > And the best kind of thinking, or more precisely the best proof that one has thought well, is to make good new things. > ... but making good new things is a should in the sense that this is how to live to one's full potential.

I urge you not to take these opinions as facts. Originality is admirable, but it is not "your potential", "proof of great thoughts", or "the most impressive thing you can do".

The answer to the question: What to do? is not "Make new things", but rather begins with a simple question: In what context?

The idea of dividing people into two categories: 1) those who "take care of people and the world", and those who 2) "make good new things", is harmful.

Does it support other scheme implementations? Or at least any plans to do so?

Will YC and startups be more or less agreeable on remote work? Will the new administration cause changes to remote work?

In general, a compiler takes source code and generates object code or an executable. Can you elaborate on what your compiler takes as input and generates as an output?

What are some other applications of WebAssembly that you find promising?

> I found no evidence of someone having invented it before.

Most Lisp/Scheme implementations offer tracing. Amazingly, the SICP book even shows tracing as a means of analyzing whether a recursive function is tail-recursive.

What I'm curious about is the Lisp history of tracing. Does anyone know which implementations were the first to provide tracing functionality?

Tail-call optimization is very important when writing Scheme programs. By removing those, you loose the power of recursion.

Also when it comes to macros, does that include `syntax-rules` or `syntax-case` style macros, where the latter are much more powerful?

While an embedded Scheme-like language is incredibly useful, at some point I feel as if you would simply have to include these features, and to that end it would just be Scheme reinvented.

Making something helps to get hired. Not only is it a show of expertise, but also an expression of your unique personality. What is more, I asked what you want to make right now. Even people afraid of failure make things.

> I want to get out of this learning loop where I keep experiencing that I know nothing so I keep learning and I think I am good for it and then I apply for jobs and the loop repeats itself.

So? Just stop learning. Close that book, video, course. Go make something people want. Or you want. What would you like to make?

It is not easy to follow. And there are many things worth discussing. I understand there are complications with MIPS and C++ just to name a few.

But let me stick with some basics. So, I can write and compile an x86 test.c program. Then, I use your extension and undo the linking. Then, I use the results to link again into a new executable? Are the executables identical? When does it break?

How much of a task is it to make it a standalone program? What about x64 support?

I am not sure if I follow correctly. Please clarify the following for me. Have you succeeded in making a tool which undoes the work of the linker?

If it sounds too good to be true, it probably is not.

If removing weights improves some metrics, that may be a clue that the model is not optimal in some sense.

How can you use or create this model for conventional non-API projects? Like to embed it within some C code?

I am brainstorming here.

In practice, perhaps a C program that acts as a validation test. The source code of this C program is not publicly available. Only the binary is distributed. Let us name the binary ctestbox.

When ctestbox is run, it creates a multiplicity of new text or binary files. Each of these is like a unit test.

Consider a tool that decompiles a binary. Given ctestbox, this tool should make a.out which when run, ideally creates identical text or binary files. Now you simply count the number of identical files as a metric.

Why Python? First, python is a language with a large open-source library. Second, I do not think it is used for software that is distributed as binaries?

I would devise a somewhat loose metric. Consider you assign a percentage as to how much a binary is disassembled. As in, 0% means the binary is in assembly and 100% means the whole binary is now C code. The ideal decompiler would result in 100% for any binary.

My prediction is that this percentage will increase with time. It would be interesting to construct data for this metric.

It is important to define the limitations of using LLMs for this endeavor. I would like to emphasize your subtle point. The compiler used for the original binary may not be the same as the one you use. The probability of this increases with time, as compilers improve or the platform on which the binary runs becomes obsolete. This is a problem for validation, as in you cannot directly compare original assembly code with assembly after compiling C code (that came from decompiling).

Perhaps assembly routines could be given a likelihood, as in how sure the LLM is that some C code maps to assembly. Then, routines with hand-coded assembly would have a lower likelihood.

The problem is interesting in at least two aspects. First, an ideal decompiler would eliminate proprietary source code. Second, the abundant publicly available C code allows you to simply make a dataset of paired ASM and source code. There is also a lot of variety with optimization level, compiler choice, and platform.

What is unclear to me is: why did the authors fine-tune the DeepSeek-Coder model? Can you train an LLM from zero with a similar dataset? How big does the LLM need to be? Can it run locally?

Which common tasks and keybindings? Can you list at least some examples?

I'm interested in collaborating. For example, from the comments it occurred to me that a 128-bit SIMD register can contain 64 2-bit values. It seems straightforward that SIMD bitwise logical operations could be used in training such models.

Does it work with other filetype converted into PDFs? For example docx, ppt, png, etc.

Those who do not know Lisp, or in this case Lambda Calculus, are doomed to reinvent it.

And yet to extend Python, for example, you write code once. To extend Lisp, you have to extend a multiplicity of implementations you find relevant.

What makes Lisp (Scheme) great (for me) is that functions are first class citizens, the prefix syntax is consistent, tail call recursion optimization makes it runnable, and metaprogramming allows for powerful abstractions. What I would also emphasize is that using lambda expressions makes you wonder when to define something and when to omit the definition. Lisp is simple to learn but difficult to master.

What I would like to do is to use Lisp to solve complex problems. The problem is that abstractions are not often efficient.

For example, consider computing the calculus product rule. An S-expression abstracts the function: (lambda (u v) (* u v). With metaprogramming, this becomes a new S-expression (lambda (u v) (+ (* (d u) v) (* u (d v)))), where (d u) and (d v) further compute the derivative. To optimize this further, you need implementation dependent code and replace abstractions of S-expressions with native machine code. This is where I feel that the troubles with Lisp start.

Consider you are the author of a SaaS. You realize that your product does not have business value in some sense. By open sourcing your SaaS, you minimize the business side and emphasize the technology side. "Look at this cool open-source SaaS I've built. I make for a great Software Engineer."

Thanks again. I have to correct my previous reply. The ESP32-S3 has an extended instruction set detailed in the technical reference manual. These include vector operations (8, 16, or 32 bit).

I'm curious, why do you believe int8 will dominate?

Thanks for the reply. I did not find public documentation for Kendryte, only a Github repository. At least the code is in English. But the AI examples include an "nncase" library which I could not find on the repository. So I could not see the instructions their accelerator has.

On the other hand, esp-nn seems to be code for the xtensa instruction set. I briefly overviewed the instructions. They seem optimized for DSP rather than ML applications. Searching for SIMD returned no arithmetic instructions. Searching for parallel returned instructions for multiply and accumulate. Further, the FPU does not compute any kind of 16-bit floating point numbers.

>ARM has also defined a new set of extensions for NN acceleration Can you provide some more info about this?

Thanks. Let me be more specific. The ESP32 included WiFi on the same chip. Is there an MCU with on-chip features for AI? Perhaps an optimized TPU combined with an MCU. Would that be an advantage?

What about you? Are you doing anything related to these fields? Why do you need the money to do work related to this?