Is there a good beginner's programming language, specifically designed for learners, maybe even kids?
Something beginners can sink their teeth into and get results quickly. Results that are more than a "Hello world!" or a program that adds two integers. Something easy to use, but a thing that can guide them through the basics.

Phrogram (née KPL) was a good example, but it has sadly died (see pics at bottom; simple interface, simple codes, yet they look and feel like a modern programming environment and language - in small).

Maybe it is an existing mainstream programming language with a simplified IDE, maybe it is a full learner's solution.

Just a few ideas what to look for in a beginner's language

  • Object oriented (ComLogo is funny, but has nothing to do with today's actual programming)
  • Good IDE (intellisense and built-in help)
  • Simple IDE with preferably a "Run" button - they can learn about translation and interpreter later (Visual Studio is amazing, but pretty intimidating for a beginner.)
  • Should be visual (commad line will never be too appealing to kids)
  • Should be free of language oddities and paradoxes (this is where most actual programming languages fail IMO)
  • The list goes on; should encourage the use of indentation, should require variable declaration, should be memory safe...

Examples from Phrogram: Phrogram example code Phrogram interface

  • 3
    $\begingroup$ For those that do not know Phrogram, could you clarify what you mean what you mean by 'language oddities and paradoxes' and how Phrogram avoided them? Additionally, since the list of requirements appears to be non-exhaustive, can you sketch the intended usage and learning goals for the students which the language you seek should help achieve? $\endgroup$ Commented May 25, 2017 at 11:50
  • $\begingroup$ I'm curious where C# and Java fail the requirements you listed. I don't necessarily disagree with you. But they seem to hit all of your bullet points, with the exception of indention maybe. Your requirements seem more like a list of things for the IDE instead of the language. $\endgroup$
    – Ryan Nutt
    Commented May 25, 2017 at 11:55
  • 1
    $\begingroup$ For someone who doesn't know Phrogram, this is not at all clear, very broad, and very opinion based. $\endgroup$
    – thesecretmaster
    Commented May 25, 2017 at 11:57
  • 2
    $\begingroup$ Perhaps of interest: en.wikipedia.org/wiki/List_of_educational_programming_languages $\endgroup$
    – wythagoras
    Commented May 26, 2017 at 16:27
  • 2
    $\begingroup$ Also see Bret Victor's excellent Learnable Programming essay that delves deeply into considerations for programming languages and environments designed for learning / understanding. $\endgroup$
    – Abraham
    Commented Jun 16, 2017 at 8:46

13 Answers 13


Scratch is a visual block-based drag-and-drop programming language designed specifically for learners, especially children. It's created by the Lifelong Kindergarten Group at the MIT Media Lab.

The language and IDE are pretty much completely connected. Here's how I see it checking off your bullet points:

  • Object oriented: It has sprites, but it's debatable whether it's truly object oriented. It can serve as an introduction to the concept though.
  • Good IDE: Yes. There's a help toolbar on the right side.
  • Simple IDE with run button: Yes.
  • Visual: It's completely visual and drag-and-drop. Typing is only needed for numbers and strings, essentially.
  • Free of language oddities and paradoxes: I'm not sure exactly what type of oddities and paradoxes you're thinking of, but Scratch tries to be helpful and avoid breaking your code whenever possible. The blocks themselves are pretty intuitive and self-explanatory.
  • Other:
    • Indentation: Since it's not text based, this is less important, but control structures (conditions and loops) do get their code indented.
    • Variable declaration: All variables must be defined before use.
    • Memory safe: Yes, it runs in Flash in the browser (next version plans to move to JS). You don't have any control over actual memory usage in your program.

Scratch was my first language, and I've been teaching it as a first language for the past several years. It's great for teaching the concepts without worrying about annoying little things like syntax.

  • $\begingroup$ Thank you! Very nice, looks really good! I'll try it in the evening. Just what I was looking for. I'll leave the question open though, in the hopes of getting some more similarly good ideas. $\endgroup$
    – vacip
    Commented May 25, 2017 at 13:12
  • $\begingroup$ Is it even possible to write scratch without the IDE? I've never heard of that happening. $\endgroup$
    – thesecretmaster
    Commented May 25, 2017 at 13:33
  • $\begingroup$ @thesecretmaster There have been some user-contributed alternate players for Scratch. Examples: Phosphorus, official HTML5 player, SB2.JS. And even some alternate IDEs: M30w (text based), Pixie (in JS). $\endgroup$
    – Scimonster
    Commented May 25, 2017 at 15:01
  • $\begingroup$ I guess Scratch is a very great child-focused option. Remember it has an online option very useful. $\endgroup$ Commented May 25, 2017 at 15:41
  • 4
    $\begingroup$ See also Scratch's cleverer, less well known brother, [Snap!](snap.berkeley.edu), and this discussion comparing them. $\endgroup$
    – Miles
    Commented May 26, 2017 at 8:09

I would consider teaching in Python if you wanted to give your students a taste of programming in a text-based language—pretty much the only type of language used professionally. A visual programming language like Scratch is probably better for younger groups, and teaches the underlying programming concepts well, but you will reach a point where you must write in a text-based programming language. There are very few programmers who work professionally in visual programming languages, so Python provides a nice 'first step'.

Note that I would specifically recommend Python 3, because it has far fewer 'oddities' that you'd like to avoid. I've briefly discussed this here in comparison to Python 2; it seems like a no brainer to teach in Python 3, which is much more intuitive.

Regarding your constraints:

  • Object-oriented: Python supports OOP, but does not enforce it. If you want to initially teach procedural programming, then move on to OOP, Python will allow you to do that. Other languages like Java require OOP, with all the boilerplate that comes with it, but Python gives you the flexibility to write either way.

  • IDE support: The default IDE, IDLE, is frankly poor. PyCharm, Jetbrains' IDE, is far superior and does support intelligent auto-complete, although the professional edition does come at a cost. PyCharm Edu, however, is free and open source. It's also worth considering whether you need an IDE at all!

  • Visual element: Initially, I suspect it'll be far easier to teach your students to write text-based programs. Don't underestimate what you can make on the command line, though—quizzes, guessing games and joke scripts are all low hanging fruit. Al Sweigart's *Invent Your Own Computer Games with Python might be a helpful resource to teach using PyGame for the visual element, but it will be much more verbose than command-line programs and will probably require some teaching to get to that level. You might find it helpful to use the turtle library for something to play with, and get instant feedback.

  • Language oddities: Python is relatively intuitive, and was designed with specific consideration for beginners. The floating point calculations might cause some confusion, but other than that, most operations work as you'd expect.

  • Indentation: Python enforces indentation, otherwise your code just won't run at all. The discipline that Python creates will probably be helpful for future, less strict languages.

  • Memory safety: Nothing to worry about here.

  • Declaring variables in advance: This point isn't really required for Python—you generally don't declare variables in advance; you just create them as needed.

Consider the benefits of a text-based language: once your students master it, they understand a general-purpose programming language used in industry. If you master Scratch, you still have to go through this step anyway to learn a text-based language.

  • 5
    $\begingroup$ +1 because Python is good, but i disagree with saying Scratch isn't a real language. It teaches the basic programming concepts without making you worry about annoying things like syntax. You can still make cool projects in Scratch that use actual algorithms. $\endgroup$
    – Scimonster
    Commented May 25, 2017 at 15:37
  • 1
    $\begingroup$ @Scimonster You're right, I think 'real' doesn't reflect what I was trying to get at—a general purpose language that can be used for nearly anything, whereas Scratch is more limited in its uses (although still has a very important place in education). In Scratch, you can make games and animations, but Python allows you to make applications, games, websites, command line programs—nearly anything. That was what I meant when I said real, although re-reading it, it did sound a bit 'snobby', so I've changed that. $\endgroup$
    – Aurora0001
    Commented May 25, 2017 at 15:44
  • 2
    $\begingroup$ +1 for mentioning turtle. The concept is simple, but it seems very effective to get interesting visual output in 'non-visual' language. $\endgroup$ Commented May 25, 2017 at 18:15
  • $\begingroup$ Check out Guido van Rossum's (Python's creator and 'benevolent dictator for life') paper on [computer programming for everyone[(legacy.python.org/doc/essays/cp4e) from 1999. $\endgroup$
    – Miles
    Commented May 26, 2017 at 8:02
  • $\begingroup$ For a simple(r) IDE for learning Python programming, also see the open-source Thonny at thonny.org. Has (sub)expression evaluation stepping, visualisation of the call stack, etc. -- all very useful for beginners especially. There is also an extension available so that you can use this same IDE for programming the BBC Micro:Bit as well. $\endgroup$
    – Abraham
    Commented Jun 16, 2017 at 11:33

Processing probably ticks a lot of your boxes. It's essentially a framework built on top of Java and shipped with its own IDE (also free and open source). A lot of the boiler plate code that normally exists in Java (package and include statements and so on) is hidden by default, so it's very clean for newbies (you can import extra packages later if you need to in the normal way). As straightforward as you'd want it to be to put together simple versions of classic games, like Pong below, which I think of as a good barometer for a teaching language.

IDE on left, intermediate project on right

  • Object oriented: fully featured Java under the hood
  • Good IDE (intellisense and built-in help): Not always perfect, but the latest version has auto-complete and auto-indenting functionality which is about as much as I want younger students to have. Little beyond that, which can be frustrating, but on balance I think it hits a nice sweet spot of simplicity and functionality. One button to compile and run.
  • Should be visual: very easy to draw shapes on screen. Can make a circle follow the mouse in six lines (including two that are just brackets). Not as easy as something like Scratch, but about as easy as I can imagine a full fat programming language being. By week 5 with a young class we have them working with mouse coordinates, colours and random numbers to put together simple animations like the below (super simple to look at here, but lots of little achievements the kids love along the way to keep it interesting. Also need semicolons, brackets, etc all correct for this) Simple lesson with Processing - shape onscreen moving and flashing

  • Should be free of language oddities and paradoxes: depends on what exactly you mean. Java probably fails this test by some reasonable measures, but that's a broader conversation.

  • The list goes on; should encourage the use of indentation, should require variable declaration, should be memory safe...: The language/IDE don't demand indentation, but it's made pretty easy to do. Requires variable declarations, is memory safe. Also provides plenty of headroom to grow into for even the most advanced students.

We've used it with students as young as 8. On the whole we've concluded that age 10-11 is a sweet spot for starting with this kind of thing (as against something like Scratch). Some 8-year-olds can definitely get to grips with Processing, but most get a little frustrated after the first 5-10 lessons at how slow progress can be. In particular the reliance on coordinates can be a very high bar for younger students to cross.

  • 2
    $\begingroup$ Just to present the other side of the coin, see Bret Victor's Learnable Programming essay that looks at (conceptually & concretely) language/environment design for learning to program with. He says JavaScript and Processing are poorly-designed languages that support weak ways of thinking, and ignore decades of learning about learning. when considering readability, making computation visible, decomposition, recomposition and more. It has global state, modes that alter the meaning of a line of code, etc., so not great for learners specifically. $\endgroup$
    – Abraham
    Commented Jun 16, 2017 at 8:41
  • $\begingroup$ @Abraham - I'm curious - I was wowed by Bret Victor's talk a couple of years back like everyone else but what actually makes him an authority on learning? He seems to be a a CS guy and an interface designer. Has he been a teacher for any length of time? An education researcher (even though education research has a horrible reputation)? $\endgroup$ Commented Jun 16, 2017 at 20:24
  • 1
    $\begingroup$ @MikeZamansky His work speaks for itself. The brilliance of it, the research that evidently goes into it and the impact that it has. But also, the organisations like MIT that invite him over, the people like Alan Kay who more-than-endorse him, etc. -- he is a design-for-humans genius. :) From human-computer interaction research and design at Apple to learn/understand/create research, been working with Alan Kay and other comp sci education and learning sciences researchers (amongst others) in essence continuing the design-for-understanding-and-human-empowerment work of especially Seymour Papert $\endgroup$
    – Abraham
    Commented Jun 16, 2017 at 22:38
  • 1
    $\begingroup$ Got it - his work speaks for itself. Just like Bill Gates when he had his theories of how schools should be run. I do think Victor's work is pretty cool and interesting but I wouldn't be willing say his personal theories are unquestionably correct until they're vetted by actual teachers. Plenty of teachers have had terrific results with those horrible tools. $\endgroup$ Commented Jun 16, 2017 at 23:03
  • $\begingroup$ See also: cseducators.stackexchange.com/questions/19/… $\endgroup$ Commented Jul 24, 2017 at 18:28

The Racket team has argued that no language that is suitable for writing any real software is great for beginners: they contain too many warts, legacy features, complex corners, etc. And that includes Racket itself. We have therefore created a series of student languages that are carefully designed subsets of the full language ideal for student use.

Think of it this way. Open an introductory programming textbook that uses some language L. Start at the beginning. Does it use all of L on page 1? Or page 10? Or even page 100? No! It begins with a very small subset of L, then grows that subset chapter by chapter, and even by the end may have exposed you to only a small part of L (if L is a language in industrial use). This is not only sensible, it's what we implicitly expect.

Now ask yourself why your programming environment doesn't do the same.

In contrast, that's what Racket does. The languages that come bundled with the main IDE, DrRacket, are tied to the text How to Design Programs. Other textbook authors have provided their own languages too, and it's easy for instructors to create their own to match whatever they are teaching.

  • 1
    $\begingroup$ As a high school educator using the student languages in the classroom, I can vouch for this philosophy! The limited feature set of the Beginning Student Language allows for excellent error messages, and allows students to feel they have "the whole language" in their heads. The Intermediate and Advanced Student Languages are the perfect "small steps" up. $\endgroup$
    – Alex Lew
    Commented Jun 16, 2017 at 21:34

I had great success by teaching kids (8 to 11 years old) to set up their sites. First, plain HTML to understand how model maps to presentation; then CSS to see how boring stuff can be factored out; then javascript to make pages alive; then CGI to do magic.

The important parts were

  • immediate tangible reward: Hey look at my page!
  • no big words (object doesn't say much to a kid)
  • all is done in a notepad, with the message that fancy tools are not really necessary
  • toolchain is introduced pretty late, when a kid is ready
  • CGI is a Creative Gentle Introduction to real programming, because they are already hooked, and want more

Of course all of that happened in late 90es. Still I believe the strategy is sound even now.

  • $\begingroup$ While I love teaching front end web stuff, I don't think that the OP is asking about that. The problem is that HTML+CSS are not "real" languages in that they cannot do logic, accept user input on their own, etc. $\endgroup$
    – thesecretmaster
    Commented May 26, 2017 at 2:34
  • 1
    $\begingroup$ @thesecretmaster Correct. The point is that it is a natural introduction into a real world. And besides, CSS does drive toward an object oriented mindset. And javascript has plenty of logics. The order is very important. $\endgroup$
    – user58697
    Commented May 26, 2017 at 2:37
  • $\begingroup$ It also doesn't match what the OP asks for. HTML+CSS are not programming languages, they are markup languages. And if you want to talk about JS, although it is a programming language, it is not free of language oddities and paradoxes, as the OP requests. $\endgroup$
    – thesecretmaster
    Commented May 26, 2017 at 2:41
  • $\begingroup$ @thesecretmaster Let's agree do disagree. HTML+CSS is a programming language, as much as Make and Prolog are. All of them transform a set of rules to the visible result. Who cares that they are not functional, or imperative, or whatever, but descriptive. $\endgroup$
    – user58697
    Commented May 26, 2017 at 2:53
  • 1
    $\begingroup$ @user58697 I concur. I think the learning comes from students manipulating and creating something that they are already familiar. Being able to go home and think they have come part of the way in understanding a real-world concept. $\endgroup$ Commented May 26, 2017 at 15:26

A variant of the Racket programming language with the DrRacket IDE is used in the course "How to Code" by Gregor Kiczales.

  • "Object oriented (ComLogo is funny, but has nothing to do with today's actual programming)." The object-oriented paradigm is not stressed in the course. "Actual programming" kind of conflicts with "learning programming".
  • "Good IDE (intellisense and built-in help)." DrRacket has built-in help, syntax highlighting, variable binding highlighting, automatic indentation.
  • "Simple IDE with preferably a "Run" button." Yes.
  • "Should be visual (command line will never be too appealing to kids)." I guess you mean that programming problems should be about graphics. There is a graphics library, and the first problem is to combine a picture from geometric primitives.
  • "Should be free of language oddities and paradoxes (this is where most actual programming languages fail IMO)." I don't understand this.
  • "Should require variable declaration." Every variable should be bound somewhere in the code, of course. The type is not declared. Racket has dynamic type system.
  • "Should be memory safe." Yes.

Teaching strategies are indicative of learning. This is as much part of learning to programming. Students need direction and to be given instruction, not just to be sat in front of a computer hoping that learning will be automatic.

Grover and Basu would agree block programming is a great introduction, but their research shows that students have general difficulties understanding programming constructs, whether using text-based or block programming language, and calls for application of learning strategies “[balancing] constructionism with other pedagogical approaches that foster deeper learning of problem solving activities and computing concepts… Activities that require students to describe what is happening” (Grover & Basu, 2017, p. 271 - 272). Measuring Student Learning in Introductory BlockBased Programming: Examining Misconceptions of Loops, Variables, and Boolean Logic.

  • 2
    $\begingroup$ That's a great article to keep in mind - thanks for sharing it. Could you elaborate a bit as to how it connects to the specific question being asked above? $\endgroup$
    – Peter
    Commented May 25, 2017 at 23:26
  • $\begingroup$ Have you seen this article about notional machines? It's fabulous. $\endgroup$
    – user737
    Commented Jul 7, 2017 at 15:27

Greenfoot is an IDE for Java which was created for teaching purposes. It displays a graphical "world" (a two dimensonal rectangle with configurable background) in which "actors" can be created, deleted, react to user input and move.

It is using Java and is therefore object-oriented, which could be demonstrated by placing multiple actors of the same class in a world. Additionally, extending classes is visualized using a tree diagram and has to be done from the beginning on as each "actor" has to be a subclass of the abstract Actor class.

As stated on the overview page of Greenfoot, it has auto-completion and a built-in access to documentation, which is (as far as I remember) quite good. The auto-completion seems to work good as well (I've just done a quick test). Auto-indentation is also included, but has to be triggered manually.

It has a "Compile" button but seems to compile automatically after saving so if you want to run your project, you can just press the "Run" button.

As to language oddities you could say it has all oddities Java has - relevant for starters might be the == or equals problem when comparing strings.

I personally always enjoy working with Greenfoot, but depending on (mental) age and programming interest of your students, a graphical language like Scratch could be a better (more motivating) choice.

As a sidenote: Greenfoot has recently introduced the "Stride" language which introduces its own syntax, forces indentation by being a bit more graphical and can be (only) used through shortcuts. I haven't extensively tested it yet, but didn't want to leave it unmentioned.


My list:

  1. Scratch
  2. Python
  3. Visual Basic (it was my first)
  4. I imagine HTML, though I was taught it with a WYSIWYG

https://www.codecademy.com/ has a good list of beginner programming languages, and extensive tutorials on most. There was a website which my teacher signed me up to which I forgot the name of. Maybe you can get a MicroBit, http://microbit.org/, and have them program those. It has click-and-point programming system, a Javascript one, a Python one and a touchscreen compatible one which is a nightmare to use on a computer.


Although out-of-style, historically, BASIC was designed for the education of non-STEM college students, is time tested, and probably allowed one of the highest ever programming literacy rates among the total base of personal computer users at one time. It might be the programming language from which a student is most likely to able to get homework help from their parents or grandparents.

BASIC can be run, interactively, without any IDE or editor, and is currently supported on the most primitive computing platforms (Grandpa's Apple II) as well as emulations within contemporary web browsers.

In spite of Dijkstra's complaints, many successful computer programmers and entrepreneurs (including now billionaires) first learned to program in BASIC, many as kids, on their own.

  • 1
    $\begingroup$ for me the issue is, it does not scale well. As in, after learning BASIC students find it difficult to relate with currently popular languages like Java and C sharp, which they eventually have to learn as it is. $\endgroup$
    – Jay
    Commented Aug 22, 2017 at 4:13
  • $\begingroup$ As a counter-point, many Basic programmers, who had to use ultra-low-level peeks and pokes, became competetent assembly language and low level C programmers. Skills which are still needed for some OS drivers, energy-harvesting IoT, embedded, and DSP development, and etc. $\endgroup$
    – hotpaw2
    Commented Dec 6, 2017 at 2:05

I am not sure if this is really what you are looking for, but there is also Blocky from Google which is kind of similar to Scratch, and lets you see the source code produced by the block in different programming languages (JavScript, Python, PHP, Dart, Lua). Blocky is used in several projects like code.org.

If Java is OK for you, than you can consider the BlueJ IDE which is:

A free Java Development Environment designed for beginners, used by millions worldwide


Dr. Java is simple IDE for Java that is designed for students. Dr. Java insist you press the 'compile' button before the 'run' button, but that is all.

A nice feature is a basic console that allows you to REPL, as in an interpreted language.

In addition, Dr. Java supports some more advanced features (without cluttering the screen), such as automated testing and code coverage with JUnit and a debugger.

To create visual output in Java, you can use the Turtle Graphics package, which visualizes the path a 'turtle', let's call him Joe, walks, according to the commands you gave Joe in Java (e.g. joe.forward(100), joe.right(90), etc.)

Although full-featured Java can be a bit daunting for the beginner, the tools I mentioned can be used to keep it simple enough to teach programming. (Turtle Graphics is, iirc, how I was introduced to programming in high-school)

An advantage of this approach over using a language designed only to learn programming, is that this approach more easily gives access to more advanced learning tools, as more people use Java than very specific learning languages.


When I started, the first language I was advised to use was C programming. We had to use Turbo C.

Although, I never got a chance to use C professionally (like when I work on software projects for enterprises and small companies and startups), I ended up teaching that so many times. From a software developer perspective, C is just not right for todays environment, but for some reason, I feel that it is the simplest language to learn, and that is what I advise to students who are young, and brand new to programming.

Here are some reasons why I would go with C (although I personally don't like that language)

  • It runs on pretty much anything, especially if students are poor (which is the harsh reality in my city) and can afford a very basic laptop which can run a older version of windows, or worst case scenario, Linux
  • Almost every university in India, has included C as part of their first year syllabus. So, there is a plenty of material, tutoring classes to find.
  • A good understanding of C can later lead to easier learning of almost any object oriented language such as C sharp, Java and if the occasion calls for it, C ++.

Especially in a scenario like what I have in my country, C fits in perfectly.

As an alternative, I also would recommend Javascript but I think it is already in one of the other answers.

  • $\begingroup$ I would differ here as Turbo-C was used here in Pakistan as well but it was exactly the reason why I kept loathing programming for a long time. C is difficult or not is a separate topic but Turbo C is an awful IDE (imo) for sure. Being a teacher, first thing I managed was keeping an arm's length between my students and Turbo C and it reaped dividends as well. $\endgroup$ Commented Sep 1, 2017 at 7:22
  • $\begingroup$ Just to clarify, I am recommending go with C but please god please don't use Turbo C indeed. Man, that thing (although OKAY at that time, 15 years ago) is just awful by todays standards. Its easier to just use an online C compiler, and if that is not available, Visual Studio or GCC. $\endgroup$
    – Jay
    Commented Sep 1, 2017 at 8:25
  • $\begingroup$ « I never got a chance to use C professionally » You were lucky you never had to program in C professionally. $\endgroup$ Commented May 3, 2018 at 12:49
  • $\begingroup$ I got to agree with that, and I do count myself lucky. I still dread C :) $\endgroup$
    – Jay
    Commented May 3, 2018 at 16:41

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.