Bouncing Ball Programming Examples
Bouncing Ball Scratch JavaScript Python Java C++ (windows) Assembler Jane

Bouncing Ball Written in seven Different Languages

  1. Scratch       -- drag and drop programming (https:/
  2. JavaScript  -- html programming
  3. Python        -- script programming
  4. Java            -- general programming
  5. C++             -- system development
  6. Assembler  -- general programming
  7. Jane            -- new (being worked on)

Download ZIP project source code files

I could easily add forty more different language examples, all doing the same thing, yet with no common foundation for the most basic of programming conventions. What I found was that there was no difference in the time or the amount of  knowledge required to write any of these examples.  If you tried, I don't think you could make it more, what is the word; nasty.

I may add more in assemblers

Video on downloading, compiling and running these examples


Things I have learned

The design of an application is greatly affected by the compiler. I use the term "compiler" to mean the thing that interrupts our programming action requests.

  1. For a 100 line application it showed the inconsistency in our software development technology
  2. Automated translation of an application from one language to another is not possible (with brute force anything is possible)
  3. Access to system parameters greatly changes the design
  4. Speed of execution changes the design
  5. Variable Scope conventions of the compiler changes the design
  6. Orientation of the screen changes naming conventions and logic
  7. No real benefit shown by any of the compiler's conventions
  8. Time to implement was the same for all compilers
  9. Readability of code was the same
  10. Documentation reading was required and about the same for all development
  11. Trivial capabilities were never consistent across languages
  12. The drag and drop programming did not make it easier
  13. I found python the most irritating to program, forcing me to do things the compiler could have done (order dependencies, scope,...)
  14. Every system had good and bad things that were arbitrary, I attributed this to the talent of the compiler's developer
  15. Teaching any of these languages is the act of knowledge transfer of language conventions not logic or design
  16. None of the languages were simple, meaning I needed to know far too much
  17. All these systems were written by/for developers, not for applicationist
  18. Coding style is very much language specific
  19. Python seemed to be the least readable
  20. Variable names were not always precise, they were adjectives of a value, not the value itself (in one design correct, in another not correct)
  21. The compiler's global scope conventions change the design and readability
  22. The early choice of a variable name is often wrong (I used "x_bounce, y_bounce", maybe should have been "x_direction, y_direction")
  23. Java had a messy form size and an odd graphic coordinate system, a lot of overhead
  24. Documentation on Python seemed version dependent, had to try a few different methods to determine if the window had closed
  25. Scratch was prone to a messy work area (difficult to manage), organization of blocks difficult to navigate, fixed operators required work to swap out, all variables should be in one place
  26. Scratch project files (*.sb3) are ZIP files (rename to .zip) then unzip, containing SVG images and a "project.json" file of blocks, comments, images, sounds and costumes
  27. Writing the Scratch Emulator was simple enough, a few hours, I only handled the block types, about 12 of them, that I used in my bouncing ball example
  28. In Assembler I had more trouble with keyword collisions, poor error messages
  29. Debugging was hit or miss, C++ (visual studio) and JavaScript (browser) debuggers best for teaching, I did not try all the support environments for the other languages
  30. Comments -- the compilers seemed to go out of their way to use something different...
  Copyright ⰱ9 Collins Software