Imagine a programming language that:

Has keywords like A, AN and THE
Lets you code what you're thinking
Can recompile itself in 3 seconds

It's Plain English.
Our Sample Application
Imagine a program that can paint:

Any person, place, or thing you name
In the style of Claude Monet
In 300 lines of Plain English code

The Complete Package

Full-Screen Desktop Interface
Super-Smooth Text Editor
Elegant Page Layout Program
Plain English Compiler and Linker
General Purpose Subroutine Library
Over 100 Pages of Documentation
Source Code for All of the Above

Frequently Asked Questions
What language is it written in? - Plain English.
Does it produce native code? - Nothing but.
Does it need a runtime library? - Absolutely not.
What do I need to run it? - Windows XP, Vista or 7. Yuk.
How big is the download? - About 1 megabyte.
What format is the documentation? - PDF with Plain English source.

to append a thing to some things:
  if the thing is nil, exit.
  put the things' last into the thing's previous.
  if the things are not empty, put the thing into the things' last's next.
  if the things are empty, put the thing into the things' first.
  put the thing into the things' last.

; my interpretation?

; append(things[], thing) { ... }    

A compiler is a preprocessor, assembler and linker.
To make a compiler:
To make an os:    

to divide a ratio by a number:
  multiply the ratio's denominator by the number.
  reduce the ratio. 

to add a string to some string things:
  create a string thing given the string.
  append the string thing to the string things.

to append a byte to a string:
  put the string's length into a saved length.
  reassign the string's first given the string's length plus 1.
  put the string's first plus the saved length into the string's last.
  put the byte into the string's last's target.
         
to rotate a polygon:
  if the polygon is nil, exit.
  put the polygon's center into a center spot.
  loop.
  get a vertex from the polygon's vertices.
  if the vertex is nil, exit.
  rotate the vertex's spot around the center.
  repeat.     
    

to add a number to another number:
  intel $8B8508000000. \ mov eax,[ebp+8] \ the number
  intel $8B00. \ mov eax,[eax]
  intel $8B9D0C000000. \ mov ebx,[ebp+12] \ the other number
  intel $0103. \ add [ebx],eax

to add a number to a byte:
  intel $8B8508000000. \ mov eax,[ebp+8] \ the number
  intel $8B00. \ mov eax,[eax]
  intel $8B9D0C000000. \ mov ebx,[ebp+12] \ the byte
  intel $0FB60B. \ movzx ecx,[ebx]
  intel $03C8. \ add ecx,eax
  intel $880B. \ mov [ebx],cl    

Here's a heated discussion with arguments on Plain English, 16+ pages started by Gerry Rzeppa (main author?). Let's invite him here to talk about it (HL forum?).

; draw bit/byte

function draw.bit, n, x, y
  if n
    draw.image bit1.i, x, y
  else
    draw.image bit0.i, x, y
  end
endf

function draw.byte, n, x, y
  locals i
  . i=8
  loop i, r0=n, r1=i, r1--, r0>>cl, r0&1
    draw.bit r0, x, y
    . x+BIT.W
  endl
endf

; draw pixel

function draw.pixel, x, y, c
  alias p=r0, z=r1
  try clip.pixel x, y
  vga.xy x, y
  . z=c, (u32) *p=z
endf 1

; draw horizontal line

function draw.line.h, x, y, n, c
  alias p=r0, z=r1, w=r2
  . p=&x, z=&y, w=&n
  try clip.line 0, p, z, w
  vga.xy x, y
  . z=c
  loop n, (u32) *p++=z, endl
endf 1

; draw solid rectangle

function draw.box, x, y, w, h, c
  locals i
  try visible x, y, w, h
  . i=y, i--
  loop h, i++
    draw.line.h x, i, w, c
  endl
endf 1

; draw scanline

function draw.scanline, pixels, x, y, w
  alias p=r0, s=r1
  vga.xy x, y
  . s=pixels
  loop w, (u32) *p++=*s++, endl
endf 1

; draw 8BPP scanline/bitmap with palette

function draw.scanline.8, pixels, x, y, w
  alias p=r0, s=r1, c=r2, q=r3
  vga.xy x, y
  . s=pixels
  loop w, q=*s++, q*4, q+palette.p
    . (u32) c=*q, (u32) *p++=c
  endl
endf 1

function draw.bitmap.8, pixels, x, y, w, h
  locals i, p
  try visible x, y, w, h
  . i=y, i--, p=pixels
  loop h, i++
    draw.scanline.8 p, x, i, w
    . r0=w, p+r0
  endl
endf 1

function draw.my.numbers
  locals i, n, y
  . i=bits.h, y=404
  loop i, r0=my.numbers, r0+i, r0--
    . r0=*r0, n=r0
    draw.byte n, 4, y
    . y-BIT.H
  endl
endf

function draw.title.scene
  draw.text help.t, 16, 130
  draw.byte magic.n, 50, 300
endf

function draw.play.scene
  draw.board
  draw.my.numbers
endf

function draw.pause.scene
  draw.text pause.t, 16, 130
  draw.byte magic.n, 50, 300
endf

function draw.game.over
  print t, game.over.t, score
  draw.text t, 44, 170
  draw.byte magic.n, 50, 300
endf

; convert 32BIT binary number to text

function b2t, n, t
  alias p=r0, x=r1
  . p=t
  if n=0, *p++='0', *p=0
    return
  end
  while n, x=n, x&1, x+'0'
    . *p++=x, n>>>1
  endw, *p=0
  text.reverse t
endf

; text.copy a, b - standard copy with
; 0 after. return advanced address

function text.copy, a, b
  alias p=r0, s=r1, c=r2
  . p=a, s=b, c=1
  while c, c=*s++, *p++=c, endw, p--
endf

; text.copy.n a, b, n - copy with maximum
; size specified. return &

function text.copy.n, a, b, n
  alias p=r0, s=r1, c=r2
  . p=a, s=b
  loop n, c=*s++, *p++=c
    if c=0, break, end
  endl, p--
endf

; text.go t, n - advance to line #

function text.go, t, n
  loop n
    try t=text.find t, 0Dh
    . t+2
  endl
endf t

; text.skip.0 a - skip 0s, return address or 0

function text.skip.0, a
  alias p=r0, c=r1
  . p=a, c='0'
  while c='0', c=*p++, endw, p--
  if c=0, return 0, end
endf

; convert text to 32BIT binary

function t2b, t
  alias p=r0, c=r1, n=r2
  try text.skip.0 t
  . n=0
  loop, c=*p++
    if c=0, return n, end
    . n<<1, n-'0', n+c
  endl
endf

function draw.my.text, t, x, y
  locals p, n
  get n=text.n t
  . p=t
  loop n, r0=p, r0=*r0
    draw.my.c r0, x, y, WHITE
    . x+r0, x+4, p++
  endl
endf

function randomize.puzzle
  locals q, n
  alias p=r0, x=r1
  . q=puzzle, n=(MAP.W*MAP.H)
  loop n
    get x=get.random
    . p=q, (u32) *p=x, q+4
  endl
endf

function is.solved
  locals n
  alias p=r0, x=r1
  . p=puzzle, n=(MAP.W*MAP.H)
  loop n, (u32) x=*p++
    if x<>NORMAL, return 0, end
  endl
endf 1

function draw.puzzle
  locals x, y
  . y=0
  while y<8, x=0
    while x<8
      . r0=x, r0*TILE.W, r0+MAP.X
      . r1=y, r1*TILE.H, r1+MAP.Y
      draw.piece x, y, r0, r1
      . x++
    endw
    . y++
  endw
endf

function on.key
  if key.event='c'
    if scene=SCENE.TITLE
      . scene=SCENE.PLAY
      go .draw
    end
    if scene=SCENE.GAME.OVER
      go .reset
    end
    if key='r'
      .reset:
      reset.game
      go .draw
    end
    if key='p'
      .pause:
      if scene=SCENE.PLAY
        . scene=SCENE.PAUSE
      else.if scene=SCENE.PAUSE
        . scene=SCENE.PLAY
      end
      go .draw
    end
    .draw:
    render
  end
endf

function on.mouse
  locals r
  if mouse.event='c'
    . r0=&close.i.x
    if.select r0
      exit
    end
    if scene=SCENE.TITLE
      reset.game
      . scene=SCENE.PLAY
      go .draw
    end
    if scene=SCENE.PLAY
      if.select puzzle.box
        get.select.xy
        get r=get.piece.rotate \
         select.x, select.y
        . r++
        set.piece.rotate \
         select.x, select.y, r
        go .draw
      end
    end
    if scene=SCENE.SOLVED
      reset.game
      . scene=SCENE.TITLE
      go .draw
    end
    .draw:
    render
  end
endf    

I big turn-off for me is the forced full-screen. No program gets to take over my entire screen for anything.

You appear to be trying to do many things at once. -Introduce a different way to write programs. -Introduce a new paradigm in menu/UI layout.

-Pretend nothing else is worth doing or using other than your system.

-Pretend that the only thing holding back programmers now is the languages they use.

I was prepared to try out a novel language...

...but when you are forcing all those other things at the same time then it feels very much like evangelising rather than normal promotion.

Am I speaking to the creator himself?

Much respect for Plain English. Pure genius.

I myself make assemblers and compilers for various CPUs

...and may be interesting in helping but have no time now (drinking too much Budweiser tonight).

So, I'll post my latest macro code and let it speak to you in a mysterious way. You will never find code like this anywhere on Earth.

There is no human like me, 1 in 7+ billion:

...programming doesn't have to be as hard as it is.

Don't you have to check all the others to really be sure? Smile

The basic idea was to get ourselves out of the Windows environment ...

Who said programming is hard?

Gerry Rzeppa wrote:

The basic idea was to get ourselves out of the Windows environment ...

Why?

You are pulling people away from their comfort zones in too many ways.

If you backed off and instead introduced your language first and get people interested, then in a separate path try to convince others about the evils of Windows etc. then you might have more success.

...with everything happening all at once you create a lot of resistance for no good reason.

It seems to me that programming with something like Corona is way easier than programming in Objective-C or Java, and that those latter approaches, by comparison, could reasonably be called "hard".

Simply learn assembly and all these difficulties will disappear like a mist in a hot summer day.

define_types \
  void(dd,'p','v'),\
  uint1(db,'i','u'), int1(db,'i','s'),\
  uint2(dw,'i','u'), int2(dw,'i','s'),\
  uint4(dd,'i','u'), int4(dd,'i','s'),\
  uint8(dq,'i','u'), int8(dq,'i','s'),\
  real4(dd,'f',0), real8(dq,'f',0)

alias \
  byte=uint1, char=int1,\
  ushort=uint2, short=int2,\
  int=int4, uint=uint4,\
  long=int8, ulong=uint8,\
  float=real4, double=real8    

make.game(...)    

But there is one catch - how about the internationalization? For example "Plain Chinese Programming", "Plain Bulgarian Programming" and "Plain Russian Programming" languages? Do you think they have some future?