You want your language to be very low level because it helps to understand what the computer is doing, yet you also want to use plain english because it is "easier and more intuitive".
Exactly. So the student can learn all about computers, from the top to tbe bottom; from his first and almost magical "Hello, World!" to the lowest level where the secrets of machine code, stacks, memory management, etc, reside.
Well, you are simply wrong and ignorant of what makes programming hard. Abstraction and logic are the two things I've seen new developers struggle with the most.
I haven't had those problems with any of my students, many of whom have gone on to lucrative careers as professional programmers, independently employed. Perhaps you're teaching the subject in an ineffective way. The key, in three words, is this: TEACHING IS TELLING. The so-called Socratic method is bunk. You want to transfer the working neural patterns in your brain into your student's brain -- not ask the student to reinvent the wheel. So you show him a problem, then you hand him the solution on a silver platter and have him type it in. (Our standard dual-monitor set up, where the teacher controls the mouse and the student controls the keyboard, is ideal for this kind of training.) Then you do it again, with the next problem. And again, and again, and again. When you see that the student is typing the right stuff
before you tell him what to type, you're done.
But beyond that, your language is fatally flawed because it was designed like a first or second generation programming language, related more closely to cobol, fortran, or APL.
Actually, more like Pascal or Oberon. But clearly that's all that's needed, both for beginner and professional. If it wasn't enough, how could we write an entire integrated development environment (including interface, file manager, text editor, hex dumper, native-code-generating compier/linker, and wysiwyg page layout facility for documentation) -- conveniently and efficiently -- with just that and no more?
The asinine focus on making it low level while still trying to make sentences is ultimately what makes this language terrible.
The beginning student doesn't need to see any of the low-level stuff. That's why, for example, we manage memory for strings automatically. But we do want the more advanced student to understand memory management, so we expose that level of detail when the student is ready to study more advanced data structures.
The fact that you completely ignore the existence and utility of the last 60 years of innovation in language and programming development shows how incredibly ignorant you are.
Yet smart enough to develop the non-trivial program under discussion. Smart enough to teach others who are now gainfully self-employed in the field. Smart enough to be self-employed in the field myself for over four decades.
Well lets start with the fact that basically your language provides functions, variables, and structs.
We would say, types, variables, and routines, in that order. But yes.
It requires the user to know and use manual memory management...
Only the advanced student/programmer (whom we want exposed to such things so he'll understand what the computer is actually doing); the beginner can work entirely with static variables.
...and also provides absolutely no help to the writer when it comes to memory leaks.
That's not true. Memory leaks (including the number "drips") are reported when a program terminates. The developer can then use our standard debugging facilities and techniques to find his error. Besides, in practice it's hardly ever a serious (or even frequent) problem -- at least not for a student trained as we train them.
You have very little in scope and namespace management, another big failing of the c language. It why many C libraries adopt function name like lib_png_sublibrary_subobject_doThing so they don't collide.
All types and routines in Plain English are global in scope, and variables are either global or local in scope. Each project is also it's own scope. This is sufficient for our needs: for teaching beginners how to write simple programs, and for teaching advanced students how to write sophisticated interfaces, editors, compilers, etc. In fact, it encourages the student not to let a program get too big, and not to integrate too many things into a single executable.
You offer very little (no?) library support, which is horrible in general. So now, everytime anyone wants to do anything they are supposed to what, copy out huge swaths of text from one project to the next? Umm, yeah, no thanks!
Yes, the developer copies the libraries (or the parts of the libraries) he needs into his project directory. (There is no separate "project management" facility in Plain English.) This insures that the developer's project will remain stable and operational even if the source library is "improved" at a later time. It's similar to the way our DNA is carried along in every cell of our bodies.
You include the ability to inline assembly and the language appears to have very strong ties to the x86 architecture. A particularly stupid design decision because, frankly, you ignore the fact that there are many, MANY, other platforms in the world.
At the time we wrote our prototype, most computers were x86s running Windows, so we chose that as our target. And sure, we could have inserted an intermediate virtual machine into our architecture, but that would have unnecessarily complicated the system for the student, and slowed performance. As I've said before, the elegance of a solution has to be judged based on the goals set for that solution -- not the personal goals of an outside observer like yourself.
Promoting one to the top is a sure fire way to make sure that is the only platform your language will ever run on.
All of the operating-system-specific stuff is in a single library in our system, and all of the machine-specific stuff is either in that library or in the compiler library. It's not a big deal to make it run on different operating systems and hardware configurations.
Global mutable state is the order of the day, sorry, that is just such a horrible mistake in language design. Most new language don't support this and for good reason, global state is just a terrible idea which will only result in problems for future maintainers. It creates tightly coupled code which is hard to understand because at any given point anyone anywhere can mutate and change the state of a variable. This leads to all sorts of nasty bugs and debugging issues.
It's a wonder, then, that our code is so simple and reliable. In over eight years of productive use, only a handful of inconsequential bugs have turned up, and a serious defect in the compiler is yet to be found.
But then you also seem completely ignorant of today's current higher order programming constructs. Immutability, for example, is a cherished and very important feature of any new language. In fact, I would go so far as to say immutability constraints are the most important feature of new languages as immutable objects and data structures prevent a huge number of bugs (primarily in the concurrency arena). Your language has none of these.
Not needed for our purposes. And our disdain for the object approach (verbs inside nouns indeed!) has been documented elsewhere in this thread.
Functional constructs such as closures and lambdas are increasingly showing their value in making highly maintainable, testable and reliable code. It makes it much easier to decouple logic and focus on individual correctness over system wide correctness. APIs designed with functional idioms in mind are simply easier to extend. They make the lives of the programmers much easier. Your language offers none of this.
The imperatives that fall from the lips of everyone on the planet, all day, every day, are typically procedural, not functional, in nature. We thus adopt a strictly procedural paradigm for our natural-language programming system. If it's not for you, fine. The "rest of us" are going to stick with the paradigm that has served humanity well for all 6000 years of recorded history.
Your language doesn't deal with concurrency at all. Given the importance of concurrency in a modern computer architecture, ignoring it completely is not wise at all.
Actually, we are forced to deal with concurrency in some spots -- the same file opened on more than one tab, for example. And we do. But it's not a major area of concern for us or our intended audience.
Data structures aren't dealt with. You have them sort of in the background. Sure, you have structs, but that is about it. Datastructures are just so important that no modern language ships without a good healthy selection.
Simple types (like numbers and strings), compound types (records or structs), and nested types (records inside other records, etc) are all built-in. As are doubly-linked lists. Our "Noodle" library also includes a handy general-purpose hash table structure that is used for compiler symbol tables, spell checking, etc. Other structures can easily (and educationally) be implemented by the student himself, when necessary. The curious thing is how unnecessary we found those other structures to be when writing a program both so broad and deep in scope.
And finally, the fact that you think English is good for programming is simply stupid. English is a terribly ambiguous language. Everything I have said in this post could have been said 10,000,000 different ways while still conveying the same meaning.
That's clearly hyperbole. The set of all potential English sentences is indeed huge; but the set of all sentence-forms that people actually use is relatively small. And the set of typical imperatives is smaller still. But if you think English is so bad for communication, and artificial languages are so much better, try writing your next post entirely in the programming language of your choice and you'll quickly see how limited it is. In fact, you'll probably end up with a Hybrid post: a natural language framework with snippets of special syntax where convenient -- which is exactly what we've been proposing.
Programming is about specificity and exactness.
No, programming is about telling a machine to do something. And the future of programming is about telling a machine to do something in the most natural and convenient way.
English wasn't designed for programming, nor was any natural language.
English has been successfully used for millennia to communicate thoughts (and, more specific to our application, commands) to others. It's no where near as bad as you make it out to be. Every successful procedure manual ever written, every instruction sheet, and yes, our Plain English system itself attests to the viability of English as a tool for productive communication. Granted, special syntaxes and graphics are helpful in certain cases; but such things are almost always found in the context of a natural language framework. Think about it. When Einstein wanted to express some thoughts that were in his mind -- and could express them in any form he chose -- he used the Hybrid approach: a natural language framework with snippets of formulas and graphics where more convenient:
This is the most natural way for us to communicate written thoughts to others. Think of a teacher in a classroom (at any educational level): he speaks -- that's the natural language framework -- and then writes formulas and draws diagrams on the board. Think of any typical text book: math, physics, biology, whatever. Think of technical whitepapers. Etc, etc.
The closest (semi-spoken) language that could be use is esperanto which was designed to be as unambiguous as possible.
Yes; and people don't like that kind of thing. It's unnatural. So instead of trying to change the way people communicate, we've opted to teach the computer how to understand people.
As far as languages go, english is probably one of the worst designed languages available.
Sure. But there it is.
Because it evolved as sort of a mixing pot of languages and language ideas, it has way too many rules, nuances, and inconsistencies. English is spoken completely differently in England, Scotland, Ireland, India, Texas, Idaho, New York, or Jamaica.
Sure. And our system allows for local dialects and modes of expression. Sometimes unusual in the eyes of outsiders, but intelligible nevertheless.
As a programmer, it would be horrible trying to understand what is going on just because someone is writing something using a different dialect.
It's not as bad as you make it out to be. When someone travels from New York to Alabama, they get by without any serious difficulty.