https://dev.to/finanalyst/creating-a-new-programming-languag...
I, personally, think this is a lamentable state of affairs that raises the barrier to entry for programming, especially for children. There are education-oriented Japanese programming languages that try to fill the niche for teaching children, but I think it would be beneficial if there were serious languages with a full ecosystem rather than ones designed to be training wheels before learning English programming languages.
Google Translate did a not terrible job of turning all the comments into English but also mangled the code in exciting new ways, but with a bit of ingenuity to apply the Artificial Intelligence translations, and a bit of bloodymindedness when applying the Analogue Idiocy to hacking it all about with search-and-replace, I got a pretty plausible translation of it.
Seeing code in my native language makes me laugh, I can't take it seriously.
foreach (apple in fruitbasket)
apple.Eat()
vs. for (int i = 0; while i < fruitbasket.Count; i++)
fruitbasket[i].Eat();
Even as a low-level programmer, I truly loathe C-style for loops. It takes several seconds to parse them, while the C#-style foreach is instantly grokkable with zero mental overhead. When you're scanning over thousands of lines of codes, the speed and ease of reading constructs like these adds up and makes a huge difference. The desire to apply human-friendly syntax to low-level programming is among the greatest motivating factors for the language I'm working on. All of that being said, I think there is a huge advantage in having code that reads like natural language you understand, rather than having keywords that are foreign and meaningless to you.LLM(eat apples in fruitbasket)
vs
foreach (apple in fruitbasket) apple.Eat()
Your comment can be repeated almost word for word here.
You can control the amount of non determinism.
And also, it is interesting that you think modern compilers are deterministic.
> And also, it is interesting that you think modern compilers are deterministic.
A compiler, unless it has a bug, will always produce output matching the specification of the language.
Guess what language the specification is written in (if it exists at all) ?
It's usually natural language, and even then, compilers deviate from the specification all the time, and the specification has bugs.
Formal specifications are a thing, but the science is nowhere mature enough to dictate what compilers do.
> unless it has a bug
Compilers are not magic, the way it follows specifications is up to the interpretation of compiler developers like yours truly. And there are tens of thousands of compiler bugs. There was a notorious LLVM pass that had more bugs than lines of code ;)
https://github.com/llvm/llvm-project/issues?q=is%3Aissue
This is a list for just the last few years after LLVM switched to the using github for tracking issues.
AI is reliable enough to not mess up this translation now, especially if you configure it right (top p, and temperature parameters).
This abstraction lifting is absolutely happening in front of our eyes now. For the exact same reason the C for loop is less readable.
The different is that you don't yet store the prompts, just the generated code. That difference is not going to last too long. Storing prompts and contexts along with generated code is likely how we are going to be doing software engineering for a few decades before whatever the next leap in technology works out to be.
This talk about replacing software engineering by people who have no idea what software engineering is gets unbelievably tedious. The advent of Javascript did nothing to replace software engineers, it just created an entirely new class of developer. It lowered the barrier to entry and allowed anybody to write inefficient, bloated, buggy, and insecure programs. Our hardware is advanced enough that for many trivial applications there is sufficient overhead for inefficient and bloated programs to exist and be "good enough" (although they are causing untold damage in the real world with security breach after security breach). However, lowering the barrier to entry does not replace the existing engineers. You still need a real software engineer to develop novel applications that use the hardware efficiently. The Duchies of Javascript and Python are simply a new country founded adjacent to, and depending upon, the Software Engineer Kingdom. Now a new duchy is being founded, one that lowers the barrier to entry further to make even more inefficient, even more bloated, even more buggy, and even more insecure programs easier than ever. For some use cases, these programs will be good enough. But they will never replace the use cases that require serious engineering, just as Javascript never did.
No, that’s your interpretation of what a programming language is, based on nostalgia and wishful thinking.
If you get a programming system that sacrifices these and works better, people are going to use those.
FYI I am a compiler developer who has contributed to about three widely used compilers, I assure you I understand what programming languages and compilers are.
Sure. That's a very large "if", though, one that evaluates to false and will continue evaluating to false for the foreseeable future. I am told over and over that I am being replaced and yet I have not seen one singular example of a real-world application of vibe coding that replaces existing software engineering. For starters, where is the vibe-coded replacement for Clang? For Linux? For IDEs? For browsers? I don't mean a concept of an idea of a browser, of course. To make the claim that the new programming system works better than the old system, it must produce something that is actually superior to what people currently use. LLMs are clearly completely and totally incapable of this. What they are capable of is making inferior software with a lower barrier to entry. Superior software is completely off the table, and it is why we don't see any existing software being replaced at scale, even though existing software absolutely has flaws and room for improvement that a "better programming system" would be able to seize upon if it existed.
That you can confidently assert that I am wrong, while having zero real-world evidence of superior software engineering produced by the new system, is indicative of a certain level of cultish thinking that is overtaking the world. Over and over and over again, people keep making these grand claims promising the world is changed, and yet there is no tangible presence of this in reality. You simply demand belief that it will change, as though LLMs are a new religion.
You are right about modern AI producing superior software engineering.
You should read the chain of comments again and try to understand the non deterministic leaps of logic you have made :)
You specifically asserted that prompts would be the future of software engineering. If my memory is not mistaken, this was edited later to hedge with "likely" and did not include that when originally written?
Your memory is as impeccable as your logic :)
> asserted that prompts would be the future of software engineering.
That’s exactly not what I asserted. Can you find the critical difference?
i'llll get my coat
Yeah, sorry, I couldn't resist. I'm not Welsh but I lived there when I was a small child, and happily holidayed there after. It is a great country.