Any simple Python GUI projects for beginner/novice programming students?












9












$begingroup$


I teach programming at a university, at 2 freshmen courses. My students are being introduced to programming for the first time, so we have to teach them about algorithms, variables, control flow, functions, arrays (lists), etc. So this course covers the very basics. And every single year I see the same outcome: they get confused, frustrated, and the common question of "what are these exercises for" always arises. We don't even cover OOP and don't teach anything GUI (only CLI programs, just for them to grasp problem solving and creating algorithms).



So this year I'm trying to take a different approach: I'd like to start my course by showing them how to build a GUI program, at first by just asking them to copy and paste, until they have a working program by the end of the first class. Of course they won't understand a thing at first. But if I show them all the topics "in action" then I can introduce them to the students during the course and review the project we made on our first class.



The thing is, I'm not exactly sure what to show them. I think something like a calculator would be far too simple and might not be too attractive to young, 18-year old students that own mobile devices and see all kinds of cool applications every day. But something like a minesweeper game might be just too big a project for me to show as an example on the first class, considering they will be watching me build a program and trying to mimic what I do without understanding yet, so if this part of my class lasts for too long it might bore them to death :P



I know my course doesn't cover GUI, but I've noticed young students are not familiar at all with command-line, so maybe I can just tell them there are things on the program I'm showcasing that they will learn in future courses. As long as they get to see examples of the more basic stuff.



So, any good suggestions?






project python







share|improve this question









$endgroup$












  • $begingroup$
    Something short to keep in mind: not every GUI platform for Python works well together with proper scoping (there are famous libraries where the mainscreen is in the global scope and can't be encapsulated, go figure). Keep in mind to check for such things if you want to teach your students to do it the "right" way, since it appears that's important to you.
    $endgroup$
    – Mast
    Jan 12 at 14:06
















9












$begingroup$


I teach programming at a university, at 2 freshmen courses. My students are being introduced to programming for the first time, so we have to teach them about algorithms, variables, control flow, functions, arrays (lists), etc. So this course covers the very basics. And every single year I see the same outcome: they get confused, frustrated, and the common question of "what are these exercises for" always arises. We don't even cover OOP and don't teach anything GUI (only CLI programs, just for them to grasp problem solving and creating algorithms).



So this year I'm trying to take a different approach: I'd like to start my course by showing them how to build a GUI program, at first by just asking them to copy and paste, until they have a working program by the end of the first class. Of course they won't understand a thing at first. But if I show them all the topics "in action" then I can introduce them to the students during the course and review the project we made on our first class.



The thing is, I'm not exactly sure what to show them. I think something like a calculator would be far too simple and might not be too attractive to young, 18-year old students that own mobile devices and see all kinds of cool applications every day. But something like a minesweeper game might be just too big a project for me to show as an example on the first class, considering they will be watching me build a program and trying to mimic what I do without understanding yet, so if this part of my class lasts for too long it might bore them to death :P



I know my course doesn't cover GUI, but I've noticed young students are not familiar at all with command-line, so maybe I can just tell them there are things on the program I'm showcasing that they will learn in future courses. As long as they get to see examples of the more basic stuff.



So, any good suggestions?






project python







share|improve this question









$endgroup$












  • $begingroup$
    Something short to keep in mind: not every GUI platform for Python works well together with proper scoping (there are famous libraries where the mainscreen is in the global scope and can't be encapsulated, go figure). Keep in mind to check for such things if you want to teach your students to do it the "right" way, since it appears that's important to you.
    $endgroup$
    – Mast
    Jan 12 at 14:06














9












9








9


2



$begingroup$


I teach programming at a university, at 2 freshmen courses. My students are being introduced to programming for the first time, so we have to teach them about algorithms, variables, control flow, functions, arrays (lists), etc. So this course covers the very basics. And every single year I see the same outcome: they get confused, frustrated, and the common question of "what are these exercises for" always arises. We don't even cover OOP and don't teach anything GUI (only CLI programs, just for them to grasp problem solving and creating algorithms).



So this year I'm trying to take a different approach: I'd like to start my course by showing them how to build a GUI program, at first by just asking them to copy and paste, until they have a working program by the end of the first class. Of course they won't understand a thing at first. But if I show them all the topics "in action" then I can introduce them to the students during the course and review the project we made on our first class.



The thing is, I'm not exactly sure what to show them. I think something like a calculator would be far too simple and might not be too attractive to young, 18-year old students that own mobile devices and see all kinds of cool applications every day. But something like a minesweeper game might be just too big a project for me to show as an example on the first class, considering they will be watching me build a program and trying to mimic what I do without understanding yet, so if this part of my class lasts for too long it might bore them to death :P



I know my course doesn't cover GUI, but I've noticed young students are not familiar at all with command-line, so maybe I can just tell them there are things on the program I'm showcasing that they will learn in future courses. As long as they get to see examples of the more basic stuff.



So, any good suggestions?






project python







share|improve this question









$endgroup$




I teach programming at a university, at 2 freshmen courses. My students are being introduced to programming for the first time, so we have to teach them about algorithms, variables, control flow, functions, arrays (lists), etc. So this course covers the very basics. And every single year I see the same outcome: they get confused, frustrated, and the common question of "what are these exercises for" always arises. We don't even cover OOP and don't teach anything GUI (only CLI programs, just for them to grasp problem solving and creating algorithms).



So this year I'm trying to take a different approach: I'd like to start my course by showing them how to build a GUI program, at first by just asking them to copy and paste, until they have a working program by the end of the first class. Of course they won't understand a thing at first. But if I show them all the topics "in action" then I can introduce them to the students during the course and review the project we made on our first class.



The thing is, I'm not exactly sure what to show them. I think something like a calculator would be far too simple and might not be too attractive to young, 18-year old students that own mobile devices and see all kinds of cool applications every day. But something like a minesweeper game might be just too big a project for me to show as an example on the first class, considering they will be watching me build a program and trying to mimic what I do without understanding yet, so if this part of my class lasts for too long it might bore them to death :P



I know my course doesn't cover GUI, but I've noticed young students are not familiar at all with command-line, so maybe I can just tell them there are things on the program I'm showcasing that they will learn in future courses. As long as they get to see examples of the more basic stuff.



So, any good suggestions?






project python




project python






share|improve this question













share|improve this question











share|improve this question




share|improve this question










asked Jan 11 at 20:10









FloellaFloella

1484




1484












  • $begingroup$
    Something short to keep in mind: not every GUI platform for Python works well together with proper scoping (there are famous libraries where the mainscreen is in the global scope and can't be encapsulated, go figure). Keep in mind to check for such things if you want to teach your students to do it the "right" way, since it appears that's important to you.
    $endgroup$
    – Mast
    Jan 12 at 14:06


















  • $begingroup$
    Something short to keep in mind: not every GUI platform for Python works well together with proper scoping (there are famous libraries where the mainscreen is in the global scope and can't be encapsulated, go figure). Keep in mind to check for such things if you want to teach your students to do it the "right" way, since it appears that's important to you.
    $endgroup$
    – Mast
    Jan 12 at 14:06
















$begingroup$
Something short to keep in mind: not every GUI platform for Python works well together with proper scoping (there are famous libraries where the mainscreen is in the global scope and can't be encapsulated, go figure). Keep in mind to check for such things if you want to teach your students to do it the "right" way, since it appears that's important to you.
$endgroup$
– Mast
Jan 12 at 14:06




$begingroup$
Something short to keep in mind: not every GUI platform for Python works well together with proper scoping (there are famous libraries where the mainscreen is in the global scope and can't be encapsulated, go figure). Keep in mind to check for such things if you want to teach your students to do it the "right" way, since it appears that's important to you.
$endgroup$
– Mast
Jan 12 at 14:06










7 Answers
7






active

oldest

votes


















7












$begingroup$

Unfortunately, GUI programming is sufficiently different from algorithmic programming that if you start with it students can get the wrong idea about what a program should look like.



For example, when I write an algorithmic program, using good OO techniques, a method of five lines is starting to be too long. The granularity of a good OO program can be very small with the complexity in the interactions between objects rather than in the methods themselves.



But GUI programs typically have long and boring methods that are mostly just messages to library code, rather than being interesting in themselves.



On the other hand, with some preparation, you can/should provide a framework in which the students can work, so that they don't start with an empty page and nothing but language features. You provide a library tailored for their education. Your library can contain the GUI code and they build the algorithms to fit it.



Back in the 1980's the book Karel the Robot by Richard Pattis did a similar thing for structured programming in Pascal. He provided a simulator along with the GUI code. Students wrote programs to make a robot do interesting things. By "interesting", I mean that the system was Turing Complete, so that, in theory, any program could be written within the framework. It actually used a very small, Pascal-like, language with only a few primitives. Students didn't actually program with integers and strings, but with the primitive elements of the simulation. But, Turing Complete.



Karel the Robot has been updated to modern OO standards and versions exist for Java, Python, and Ruby. The Java version has been used for APCS courses and in college level courses as well.



For Java, there is a special resource called the Greenroom that provides many other teacher-written simulation frameworks in which the students program. I don't know of a similar resource for Python, but you could, perhaps tailor some of the ideas there to Python.






share|improve this answer









$endgroup$













  • $begingroup$
    I've used hour of code for tools similar to the Greenroom (there are some college level materials and some of the games are great practice sessions for college students, think 15-20 min instead of 4x45 minute lessons) - I've specifically used these games to teach event-driven programming for a web/phone based course I helped with
    $endgroup$
    – JGreenwell
    Jan 13 at 4:31



















9












$begingroup$

In my experience, good introductory programming courses meet three overarching goals:





  1. Empower students to create simple programs outside of the scope of the class by giving them the technical skills and the practice to begin being independent. This includes teaching the basics of one usable language.


  2. Inspire students to continue learning and using their skills once the class ends (independently and/or by signing up for the next class in the sequence).


  3. Prepare students for the next step in their learning. In many cases, this means that certain topics and concepts must be covered so that students can enter the next class at the correct level. It should also include giving students practice with the skills needed for basic independent learning including debugging, googling to find solutions to problems, and initial exposure to reading and utilizing documentation.


It sounds like you have seen issues with goal number two, where your students do not feel inspired. However, I am concerned that introducing your introductory students to GUI building right off the bat will jeopardize goal number one. GUI has a lot of overhead, and as you said, your students will not understand what they are doing and will be frustrated by their inability to build anything without heavy guidance/pre-built pieces.



My suggestion is to strike a middle balance. Have them build command line applications that they fully understand, but that are interesting or useful in some way. Better yet, give them some choice in which projects to tackle so that they are more invested.



Here are some neat things that students of mine have built in the command line without any OOP:




  • Guess the Number Game (the computer generates a number and tells the user if they are too high or too low)

  • Fortune Teller Games (using arrays and randomization)

  • Personality Quiz

  • Hangman Game

  • Random Name Generator

  • Text Based Adventure

  • Reverse Guess the Number Game (The user picks a number and the computer has to guess. This is a great jumping off point for first introducing the concept of an algorithm, since the program needs to make "smart" decisions.)

  • Minesweeper, battleship, connect four, etc. are great for 2D arrays/lists when you get there

  • Flash Card Application (students can even actually use this to study for tests for other classes!)

  • Calculator (if that's too easy, have it do harder math. Can your students build a calculator that solves algebraic equations? Can they make it take derivatives? Solve trig problems? You can apply it to whatever math they likely are learning at the time)

  • To do list manager

  • An application that manages a student roster or waitlist for a class


I hope these ideas help!






share|improve this answer











$endgroup$









  • 4




    $begingroup$
    These are great ideas for text-based games; that's what I was going to suggest but your list is more complete than mine would have been. Welcome to the site; hope you stick around! :)
    $endgroup$
    – Wildcard
    Jan 12 at 1:29






  • 3




    $begingroup$
    I disagree that debugging skills should be considered as independent learning. They should be covered by the course itself.
    $endgroup$
    – Bergi
    Jan 12 at 17:49










  • $begingroup$
    Ah, I may have not been clear. I think that students should be explicitly taught the core skills that enable them to work independently, and I included debugging in that list. I certainly don't think that students should have to learn debugging on their own. Rather, that learning it enables them to be more independent.
    $endgroup$
    – Green Griffin
    Jan 12 at 22:16



















2












$begingroup$

There is a good class on Coursera for interactive game programming in Python by some professors from Rice University, which I used when I started learning Python. It's really good at introducing the ideas very gradually, but eventually creates a pretty sophisticated game.



There might be some ideas you can get from the course, or maybe you could do an inverted classroom?
https://www.coursera.org/learn/interactive-python-1






share|improve this answer









$endgroup$





















    1












    $begingroup$

    What about a circuit python project to finish off the semester? There's no GUI as such, but you can show them a cool demo, then have them learn codes that builds towards some kind of cool interactive project. Doesn't have to be big or expensive, but lets them truly make something tangible out of their code. An Arduino was really the first thing that got me motivated to stick with programming.






    share|improve this answer









    $endgroup$









    • 1




      $begingroup$
      Please say more about "circuit python". An example would be good. What is a "cool" demo or a "cool interactive project"?
      $endgroup$
      – Buffy
      Jan 12 at 20:36










    • $begingroup$
      Depends on the scope of the class, so I'd say it's up to the OP. My point really is that building something practical, and hands on, can help ground programming. Turning LEDs different colors at the touch of a button, or having them activate based on a particular level of sound or light, can help turn more abstract concepts into something tangible.
      $endgroup$
      – Britton
      Jan 13 at 15:43



















    1












    $begingroup$

    There is little point these days in making a GUI program, except in the most rare cases, especially with Python. In the age of the internet, most programs are best served as web apps. I expect this will be most relevant to your students' interests as well. For Python I would suggest starting with Flask or Django. There are good Django tutorials here:




    • https://docs.djangoproject.com/en/2.1/intro/tutorial01/


    • https://tutorial.djangogirls.org/en/



    And I like this Flask one:




    • https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world


    All of these should show you how to make a basic app, which has a GUI in the form of a web interface.



    You might also consider something more visual in the form of basic data analysis and plotting with Jupyter notebooks.






    share|improve this answer











    $endgroup$









    • 3




      $begingroup$
      This requires the students to understand all kinds of web techniques, most notably HTTP and HTML, which might be too advanced for freshmen students (without being the actual subject of the course). It makes more sense at a later stage of the curriculum when they already learned about network stuff.
      $endgroup$
      – Bergi
      Jan 12 at 17:57












    • $begingroup$
      How is a web app not a GUI? The client is quite graphic usually.
      $endgroup$
      – Mast
      Jan 12 at 21:22












    • $begingroup$
      @mast with Python? the web app would be a GUI app (if its actually an app not an interface) but its not event driven like a standalone GUI app would be (or rather to make it event driven you would have to switch to Javascript) - so it would end up not teaching the students the same lessons (or language). I wouldn't say standalone GUIs are rare - remember cell phone games and tools as well as office applications are still typically stand-alones. Just depends on the field (like I will probably never write another serious webapp but GUIs? yeah, all the time in C# with python backend)
      $endgroup$
      – JGreenwell
      Jan 13 at 4:05










    • $begingroup$
      @JGreenwell thats what I was getting at. Creating the actual GUI for those apps is often not done with Python. The skills to build a web app may be outside the scope of a freshman curriculum, but you should not forget that this is probably why those students signed up for Computer Science in the first place; to learn mainstream app building techniques. I doubt they signed up because they wanted to learn algorithms. And both Flask and Django are easy enough to learn from the tutorials I posted, I taught myself both using these.
      $endgroup$
      – user5359531
      Jan 13 at 10:58





















    1












    $begingroup$

    On command line



    To make command line programs make sense, you need to first teach Unix (Or another OS with a workable command line: VMS, Amiga-dos, sorry I can't think of any others that are still relevant).



    When one can see the value in a powerful command line, where one can complete tasks much more quickly and with less pain, then it becomes obvious why one would write ones own command line programs.



    On GUI



    Yes for graphical programming, but this is not GUI programming.



    I have used python turtle, it aids learning because it gives immediate feedback. I have used it to teach the basics, in schools. It could also be used to teach algorithms: First teach basics, then add drawing of data sets, then …



    UnPlugged



    Also consider teaching some of it unplugged. You can teach algorithms, by having the students be the data, by having a student direct, by having a student explain, by using props e.g. backs of cards, white boards, paper, mini-whiteboards, …



    See https://csunplugged.org/en/ for some ideas. This site is aimed at primary school teachers, but most of it can be adapted.






    share|improve this answer









    $endgroup$





















      1












      $begingroup$

      I teach event-driven GUI programming in Java. This requires machinery. First of all, students need to be good at writing functions and procedural programs. Secondly, they need to understand polymorphism and inheritance, as these are vital tools. So, we are beyond the range of beginners here.



      However, if you teaching Java, GUIs are a compelling use case for the whole inheritance mechanism. Java8 lambdas make the writing of callbacks simpler and more fun. I use the JavaFX framework for this purpose. If you are doing this in java11, it is tricky to get set up and configured.



      I don't see this as a game for novices.






      share|improve this answer









      $endgroup$













        Your Answer





        StackExchange.ifUsing("editor", function () {
        return StackExchange.using("mathjaxEditing", function () {
        StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
        StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
        });
        });
        }, "mathjax-editing");

        StackExchange.ready(function() {
        var channelOptions = {
        tags: "".split(" "),
        id: "678"
        };
        initTagRenderer("".split(" "), "".split(" "), channelOptions);

        StackExchange.using("externalEditor", function() {
        // Have to fire editor after snippets, if snippets enabled
        if (StackExchange.settings.snippets.snippetsEnabled) {
        StackExchange.using("snippets", function() {
        createEditor();
        });
        }
        else {
        createEditor();
        }
        });

        function createEditor() {
        StackExchange.prepareEditor({
        heartbeatType: 'answer',
        autoActivateHeartbeat: false,
        convertImagesToLinks: false,
        noModals: true,
        showLowRepImageUploadWarning: true,
        reputationToPostImages: null,
        bindNavPrevention: true,
        postfix: "",
        imageUploader: {
        brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
        contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
        allowUrls: true
        },
        onDemand: true,
        discardSelector: ".discard-answer"
        ,immediatelyShowMarkdownHelp:true
        });


        }
        });














        draft saved

        draft discarded


















        StackExchange.ready(
        function () {
        StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcseducators.stackexchange.com%2fquestions%2f5358%2fany-simple-python-gui-projects-for-beginner-novice-programming-students%23new-answer', 'question_page');
        }
        );

        Post as a guest















        Required, but never shown

























        7 Answers
        7






        active

        oldest

        votes








        7 Answers
        7






        active

        oldest

        votes









        active

        oldest

        votes






        active

        oldest

        votes









        7












        $begingroup$

        Unfortunately, GUI programming is sufficiently different from algorithmic programming that if you start with it students can get the wrong idea about what a program should look like.



        For example, when I write an algorithmic program, using good OO techniques, a method of five lines is starting to be too long. The granularity of a good OO program can be very small with the complexity in the interactions between objects rather than in the methods themselves.



        But GUI programs typically have long and boring methods that are mostly just messages to library code, rather than being interesting in themselves.



        On the other hand, with some preparation, you can/should provide a framework in which the students can work, so that they don't start with an empty page and nothing but language features. You provide a library tailored for their education. Your library can contain the GUI code and they build the algorithms to fit it.



        Back in the 1980's the book Karel the Robot by Richard Pattis did a similar thing for structured programming in Pascal. He provided a simulator along with the GUI code. Students wrote programs to make a robot do interesting things. By "interesting", I mean that the system was Turing Complete, so that, in theory, any program could be written within the framework. It actually used a very small, Pascal-like, language with only a few primitives. Students didn't actually program with integers and strings, but with the primitive elements of the simulation. But, Turing Complete.



        Karel the Robot has been updated to modern OO standards and versions exist for Java, Python, and Ruby. The Java version has been used for APCS courses and in college level courses as well.



        For Java, there is a special resource called the Greenroom that provides many other teacher-written simulation frameworks in which the students program. I don't know of a similar resource for Python, but you could, perhaps tailor some of the ideas there to Python.






        share|improve this answer









        $endgroup$













        • $begingroup$
          I've used hour of code for tools similar to the Greenroom (there are some college level materials and some of the games are great practice sessions for college students, think 15-20 min instead of 4x45 minute lessons) - I've specifically used these games to teach event-driven programming for a web/phone based course I helped with
          $endgroup$
          – JGreenwell
          Jan 13 at 4:31
















        7












        $begingroup$

        Unfortunately, GUI programming is sufficiently different from algorithmic programming that if you start with it students can get the wrong idea about what a program should look like.



        For example, when I write an algorithmic program, using good OO techniques, a method of five lines is starting to be too long. The granularity of a good OO program can be very small with the complexity in the interactions between objects rather than in the methods themselves.



        But GUI programs typically have long and boring methods that are mostly just messages to library code, rather than being interesting in themselves.



        On the other hand, with some preparation, you can/should provide a framework in which the students can work, so that they don't start with an empty page and nothing but language features. You provide a library tailored for their education. Your library can contain the GUI code and they build the algorithms to fit it.



        Back in the 1980's the book Karel the Robot by Richard Pattis did a similar thing for structured programming in Pascal. He provided a simulator along with the GUI code. Students wrote programs to make a robot do interesting things. By "interesting", I mean that the system was Turing Complete, so that, in theory, any program could be written within the framework. It actually used a very small, Pascal-like, language with only a few primitives. Students didn't actually program with integers and strings, but with the primitive elements of the simulation. But, Turing Complete.



        Karel the Robot has been updated to modern OO standards and versions exist for Java, Python, and Ruby. The Java version has been used for APCS courses and in college level courses as well.



        For Java, there is a special resource called the Greenroom that provides many other teacher-written simulation frameworks in which the students program. I don't know of a similar resource for Python, but you could, perhaps tailor some of the ideas there to Python.






        share|improve this answer









        $endgroup$













        • $begingroup$
          I've used hour of code for tools similar to the Greenroom (there are some college level materials and some of the games are great practice sessions for college students, think 15-20 min instead of 4x45 minute lessons) - I've specifically used these games to teach event-driven programming for a web/phone based course I helped with
          $endgroup$
          – JGreenwell
          Jan 13 at 4:31














        7












        7








        7





        $begingroup$

        Unfortunately, GUI programming is sufficiently different from algorithmic programming that if you start with it students can get the wrong idea about what a program should look like.



        For example, when I write an algorithmic program, using good OO techniques, a method of five lines is starting to be too long. The granularity of a good OO program can be very small with the complexity in the interactions between objects rather than in the methods themselves.



        But GUI programs typically have long and boring methods that are mostly just messages to library code, rather than being interesting in themselves.



        On the other hand, with some preparation, you can/should provide a framework in which the students can work, so that they don't start with an empty page and nothing but language features. You provide a library tailored for their education. Your library can contain the GUI code and they build the algorithms to fit it.



        Back in the 1980's the book Karel the Robot by Richard Pattis did a similar thing for structured programming in Pascal. He provided a simulator along with the GUI code. Students wrote programs to make a robot do interesting things. By "interesting", I mean that the system was Turing Complete, so that, in theory, any program could be written within the framework. It actually used a very small, Pascal-like, language with only a few primitives. Students didn't actually program with integers and strings, but with the primitive elements of the simulation. But, Turing Complete.



        Karel the Robot has been updated to modern OO standards and versions exist for Java, Python, and Ruby. The Java version has been used for APCS courses and in college level courses as well.



        For Java, there is a special resource called the Greenroom that provides many other teacher-written simulation frameworks in which the students program. I don't know of a similar resource for Python, but you could, perhaps tailor some of the ideas there to Python.






        share|improve this answer









        $endgroup$



        Unfortunately, GUI programming is sufficiently different from algorithmic programming that if you start with it students can get the wrong idea about what a program should look like.



        For example, when I write an algorithmic program, using good OO techniques, a method of five lines is starting to be too long. The granularity of a good OO program can be very small with the complexity in the interactions between objects rather than in the methods themselves.



        But GUI programs typically have long and boring methods that are mostly just messages to library code, rather than being interesting in themselves.



        On the other hand, with some preparation, you can/should provide a framework in which the students can work, so that they don't start with an empty page and nothing but language features. You provide a library tailored for their education. Your library can contain the GUI code and they build the algorithms to fit it.



        Back in the 1980's the book Karel the Robot by Richard Pattis did a similar thing for structured programming in Pascal. He provided a simulator along with the GUI code. Students wrote programs to make a robot do interesting things. By "interesting", I mean that the system was Turing Complete, so that, in theory, any program could be written within the framework. It actually used a very small, Pascal-like, language with only a few primitives. Students didn't actually program with integers and strings, but with the primitive elements of the simulation. But, Turing Complete.



        Karel the Robot has been updated to modern OO standards and versions exist for Java, Python, and Ruby. The Java version has been used for APCS courses and in college level courses as well.



        For Java, there is a special resource called the Greenroom that provides many other teacher-written simulation frameworks in which the students program. I don't know of a similar resource for Python, but you could, perhaps tailor some of the ideas there to Python.







        share|improve this answer












        share|improve this answer



        share|improve this answer










        answered Jan 11 at 21:15









        BuffyBuffy

        21.6k84083




        21.6k84083












        • $begingroup$
          I've used hour of code for tools similar to the Greenroom (there are some college level materials and some of the games are great practice sessions for college students, think 15-20 min instead of 4x45 minute lessons) - I've specifically used these games to teach event-driven programming for a web/phone based course I helped with
          $endgroup$
          – JGreenwell
          Jan 13 at 4:31


















        • $begingroup$
          I've used hour of code for tools similar to the Greenroom (there are some college level materials and some of the games are great practice sessions for college students, think 15-20 min instead of 4x45 minute lessons) - I've specifically used these games to teach event-driven programming for a web/phone based course I helped with
          $endgroup$
          – JGreenwell
          Jan 13 at 4:31
















        $begingroup$
        I've used hour of code for tools similar to the Greenroom (there are some college level materials and some of the games are great practice sessions for college students, think 15-20 min instead of 4x45 minute lessons) - I've specifically used these games to teach event-driven programming for a web/phone based course I helped with
        $endgroup$
        – JGreenwell
        Jan 13 at 4:31




        $begingroup$
        I've used hour of code for tools similar to the Greenroom (there are some college level materials and some of the games are great practice sessions for college students, think 15-20 min instead of 4x45 minute lessons) - I've specifically used these games to teach event-driven programming for a web/phone based course I helped with
        $endgroup$
        – JGreenwell
        Jan 13 at 4:31











        9












        $begingroup$

        In my experience, good introductory programming courses meet three overarching goals:





        1. Empower students to create simple programs outside of the scope of the class by giving them the technical skills and the practice to begin being independent. This includes teaching the basics of one usable language.


        2. Inspire students to continue learning and using their skills once the class ends (independently and/or by signing up for the next class in the sequence).


        3. Prepare students for the next step in their learning. In many cases, this means that certain topics and concepts must be covered so that students can enter the next class at the correct level. It should also include giving students practice with the skills needed for basic independent learning including debugging, googling to find solutions to problems, and initial exposure to reading and utilizing documentation.


        It sounds like you have seen issues with goal number two, where your students do not feel inspired. However, I am concerned that introducing your introductory students to GUI building right off the bat will jeopardize goal number one. GUI has a lot of overhead, and as you said, your students will not understand what they are doing and will be frustrated by their inability to build anything without heavy guidance/pre-built pieces.



        My suggestion is to strike a middle balance. Have them build command line applications that they fully understand, but that are interesting or useful in some way. Better yet, give them some choice in which projects to tackle so that they are more invested.



        Here are some neat things that students of mine have built in the command line without any OOP:




        • Guess the Number Game (the computer generates a number and tells the user if they are too high or too low)

        • Fortune Teller Games (using arrays and randomization)

        • Personality Quiz

        • Hangman Game

        • Random Name Generator

        • Text Based Adventure

        • Reverse Guess the Number Game (The user picks a number and the computer has to guess. This is a great jumping off point for first introducing the concept of an algorithm, since the program needs to make "smart" decisions.)

        • Minesweeper, battleship, connect four, etc. are great for 2D arrays/lists when you get there

        • Flash Card Application (students can even actually use this to study for tests for other classes!)

        • Calculator (if that's too easy, have it do harder math. Can your students build a calculator that solves algebraic equations? Can they make it take derivatives? Solve trig problems? You can apply it to whatever math they likely are learning at the time)

        • To do list manager

        • An application that manages a student roster or waitlist for a class


        I hope these ideas help!






        share|improve this answer











        $endgroup$









        • 4




          $begingroup$
          These are great ideas for text-based games; that's what I was going to suggest but your list is more complete than mine would have been. Welcome to the site; hope you stick around! :)
          $endgroup$
          – Wildcard
          Jan 12 at 1:29






        • 3




          $begingroup$
          I disagree that debugging skills should be considered as independent learning. They should be covered by the course itself.
          $endgroup$
          – Bergi
          Jan 12 at 17:49










        • $begingroup$
          Ah, I may have not been clear. I think that students should be explicitly taught the core skills that enable them to work independently, and I included debugging in that list. I certainly don't think that students should have to learn debugging on their own. Rather, that learning it enables them to be more independent.
          $endgroup$
          – Green Griffin
          Jan 12 at 22:16
















        9












        $begingroup$

        In my experience, good introductory programming courses meet three overarching goals:





        1. Empower students to create simple programs outside of the scope of the class by giving them the technical skills and the practice to begin being independent. This includes teaching the basics of one usable language.


        2. Inspire students to continue learning and using their skills once the class ends (independently and/or by signing up for the next class in the sequence).


        3. Prepare students for the next step in their learning. In many cases, this means that certain topics and concepts must be covered so that students can enter the next class at the correct level. It should also include giving students practice with the skills needed for basic independent learning including debugging, googling to find solutions to problems, and initial exposure to reading and utilizing documentation.


        It sounds like you have seen issues with goal number two, where your students do not feel inspired. However, I am concerned that introducing your introductory students to GUI building right off the bat will jeopardize goal number one. GUI has a lot of overhead, and as you said, your students will not understand what they are doing and will be frustrated by their inability to build anything without heavy guidance/pre-built pieces.



        My suggestion is to strike a middle balance. Have them build command line applications that they fully understand, but that are interesting or useful in some way. Better yet, give them some choice in which projects to tackle so that they are more invested.



        Here are some neat things that students of mine have built in the command line without any OOP:




        • Guess the Number Game (the computer generates a number and tells the user if they are too high or too low)

        • Fortune Teller Games (using arrays and randomization)

        • Personality Quiz

        • Hangman Game

        • Random Name Generator

        • Text Based Adventure

        • Reverse Guess the Number Game (The user picks a number and the computer has to guess. This is a great jumping off point for first introducing the concept of an algorithm, since the program needs to make "smart" decisions.)

        • Minesweeper, battleship, connect four, etc. are great for 2D arrays/lists when you get there

        • Flash Card Application (students can even actually use this to study for tests for other classes!)

        • Calculator (if that's too easy, have it do harder math. Can your students build a calculator that solves algebraic equations? Can they make it take derivatives? Solve trig problems? You can apply it to whatever math they likely are learning at the time)

        • To do list manager

        • An application that manages a student roster or waitlist for a class


        I hope these ideas help!






        share|improve this answer











        $endgroup$









        • 4




          $begingroup$
          These are great ideas for text-based games; that's what I was going to suggest but your list is more complete than mine would have been. Welcome to the site; hope you stick around! :)
          $endgroup$
          – Wildcard
          Jan 12 at 1:29






        • 3




          $begingroup$
          I disagree that debugging skills should be considered as independent learning. They should be covered by the course itself.
          $endgroup$
          – Bergi
          Jan 12 at 17:49










        • $begingroup$
          Ah, I may have not been clear. I think that students should be explicitly taught the core skills that enable them to work independently, and I included debugging in that list. I certainly don't think that students should have to learn debugging on their own. Rather, that learning it enables them to be more independent.
          $endgroup$
          – Green Griffin
          Jan 12 at 22:16














        9












        9








        9





        $begingroup$

        In my experience, good introductory programming courses meet three overarching goals:





        1. Empower students to create simple programs outside of the scope of the class by giving them the technical skills and the practice to begin being independent. This includes teaching the basics of one usable language.


        2. Inspire students to continue learning and using their skills once the class ends (independently and/or by signing up for the next class in the sequence).


        3. Prepare students for the next step in their learning. In many cases, this means that certain topics and concepts must be covered so that students can enter the next class at the correct level. It should also include giving students practice with the skills needed for basic independent learning including debugging, googling to find solutions to problems, and initial exposure to reading and utilizing documentation.


        It sounds like you have seen issues with goal number two, where your students do not feel inspired. However, I am concerned that introducing your introductory students to GUI building right off the bat will jeopardize goal number one. GUI has a lot of overhead, and as you said, your students will not understand what they are doing and will be frustrated by their inability to build anything without heavy guidance/pre-built pieces.



        My suggestion is to strike a middle balance. Have them build command line applications that they fully understand, but that are interesting or useful in some way. Better yet, give them some choice in which projects to tackle so that they are more invested.



        Here are some neat things that students of mine have built in the command line without any OOP:




        • Guess the Number Game (the computer generates a number and tells the user if they are too high or too low)

        • Fortune Teller Games (using arrays and randomization)

        • Personality Quiz

        • Hangman Game

        • Random Name Generator

        • Text Based Adventure

        • Reverse Guess the Number Game (The user picks a number and the computer has to guess. This is a great jumping off point for first introducing the concept of an algorithm, since the program needs to make "smart" decisions.)

        • Minesweeper, battleship, connect four, etc. are great for 2D arrays/lists when you get there

        • Flash Card Application (students can even actually use this to study for tests for other classes!)

        • Calculator (if that's too easy, have it do harder math. Can your students build a calculator that solves algebraic equations? Can they make it take derivatives? Solve trig problems? You can apply it to whatever math they likely are learning at the time)

        • To do list manager

        • An application that manages a student roster or waitlist for a class


        I hope these ideas help!






        share|improve this answer











        $endgroup$



        In my experience, good introductory programming courses meet three overarching goals:





        1. Empower students to create simple programs outside of the scope of the class by giving them the technical skills and the practice to begin being independent. This includes teaching the basics of one usable language.


        2. Inspire students to continue learning and using their skills once the class ends (independently and/or by signing up for the next class in the sequence).


        3. Prepare students for the next step in their learning. In many cases, this means that certain topics and concepts must be covered so that students can enter the next class at the correct level. It should also include giving students practice with the skills needed for basic independent learning including debugging, googling to find solutions to problems, and initial exposure to reading and utilizing documentation.


        It sounds like you have seen issues with goal number two, where your students do not feel inspired. However, I am concerned that introducing your introductory students to GUI building right off the bat will jeopardize goal number one. GUI has a lot of overhead, and as you said, your students will not understand what they are doing and will be frustrated by their inability to build anything without heavy guidance/pre-built pieces.



        My suggestion is to strike a middle balance. Have them build command line applications that they fully understand, but that are interesting or useful in some way. Better yet, give them some choice in which projects to tackle so that they are more invested.



        Here are some neat things that students of mine have built in the command line without any OOP:




        • Guess the Number Game (the computer generates a number and tells the user if they are too high or too low)

        • Fortune Teller Games (using arrays and randomization)

        • Personality Quiz

        • Hangman Game

        • Random Name Generator

        • Text Based Adventure

        • Reverse Guess the Number Game (The user picks a number and the computer has to guess. This is a great jumping off point for first introducing the concept of an algorithm, since the program needs to make "smart" decisions.)

        • Minesweeper, battleship, connect four, etc. are great for 2D arrays/lists when you get there

        • Flash Card Application (students can even actually use this to study for tests for other classes!)

        • Calculator (if that's too easy, have it do harder math. Can your students build a calculator that solves algebraic equations? Can they make it take derivatives? Solve trig problems? You can apply it to whatever math they likely are learning at the time)

        • To do list manager

        • An application that manages a student roster or waitlist for a class


        I hope these ideas help!







        share|improve this answer














        share|improve this answer



        share|improve this answer








        edited Jan 13 at 18:40

























        answered Jan 11 at 22:23









        Green GriffinGreen Griffin

        2114




        2114








        • 4




          $begingroup$
          These are great ideas for text-based games; that's what I was going to suggest but your list is more complete than mine would have been. Welcome to the site; hope you stick around! :)
          $endgroup$
          – Wildcard
          Jan 12 at 1:29






        • 3




          $begingroup$
          I disagree that debugging skills should be considered as independent learning. They should be covered by the course itself.
          $endgroup$
          – Bergi
          Jan 12 at 17:49










        • $begingroup$
          Ah, I may have not been clear. I think that students should be explicitly taught the core skills that enable them to work independently, and I included debugging in that list. I certainly don't think that students should have to learn debugging on their own. Rather, that learning it enables them to be more independent.
          $endgroup$
          – Green Griffin
          Jan 12 at 22:16














        • 4




          $begingroup$
          These are great ideas for text-based games; that's what I was going to suggest but your list is more complete than mine would have been. Welcome to the site; hope you stick around! :)
          $endgroup$
          – Wildcard
          Jan 12 at 1:29






        • 3




          $begingroup$
          I disagree that debugging skills should be considered as independent learning. They should be covered by the course itself.
          $endgroup$
          – Bergi
          Jan 12 at 17:49










        • $begingroup$
          Ah, I may have not been clear. I think that students should be explicitly taught the core skills that enable them to work independently, and I included debugging in that list. I certainly don't think that students should have to learn debugging on their own. Rather, that learning it enables them to be more independent.
          $endgroup$
          – Green Griffin
          Jan 12 at 22:16








        4




        4




        $begingroup$
        These are great ideas for text-based games; that's what I was going to suggest but your list is more complete than mine would have been. Welcome to the site; hope you stick around! :)
        $endgroup$
        – Wildcard
        Jan 12 at 1:29




        $begingroup$
        These are great ideas for text-based games; that's what I was going to suggest but your list is more complete than mine would have been. Welcome to the site; hope you stick around! :)
        $endgroup$
        – Wildcard
        Jan 12 at 1:29




        3




        3




        $begingroup$
        I disagree that debugging skills should be considered as independent learning. They should be covered by the course itself.
        $endgroup$
        – Bergi
        Jan 12 at 17:49




        $begingroup$
        I disagree that debugging skills should be considered as independent learning. They should be covered by the course itself.
        $endgroup$
        – Bergi
        Jan 12 at 17:49












        $begingroup$
        Ah, I may have not been clear. I think that students should be explicitly taught the core skills that enable them to work independently, and I included debugging in that list. I certainly don't think that students should have to learn debugging on their own. Rather, that learning it enables them to be more independent.
        $endgroup$
        – Green Griffin
        Jan 12 at 22:16




        $begingroup$
        Ah, I may have not been clear. I think that students should be explicitly taught the core skills that enable them to work independently, and I included debugging in that list. I certainly don't think that students should have to learn debugging on their own. Rather, that learning it enables them to be more independent.
        $endgroup$
        – Green Griffin
        Jan 12 at 22:16











        2












        $begingroup$

        There is a good class on Coursera for interactive game programming in Python by some professors from Rice University, which I used when I started learning Python. It's really good at introducing the ideas very gradually, but eventually creates a pretty sophisticated game.



        There might be some ideas you can get from the course, or maybe you could do an inverted classroom?
        https://www.coursera.org/learn/interactive-python-1






        share|improve this answer









        $endgroup$


















          2












          $begingroup$

          There is a good class on Coursera for interactive game programming in Python by some professors from Rice University, which I used when I started learning Python. It's really good at introducing the ideas very gradually, but eventually creates a pretty sophisticated game.



          There might be some ideas you can get from the course, or maybe you could do an inverted classroom?
          https://www.coursera.org/learn/interactive-python-1






          share|improve this answer









          $endgroup$
















            2












            2








            2





            $begingroup$

            There is a good class on Coursera for interactive game programming in Python by some professors from Rice University, which I used when I started learning Python. It's really good at introducing the ideas very gradually, but eventually creates a pretty sophisticated game.



            There might be some ideas you can get from the course, or maybe you could do an inverted classroom?
            https://www.coursera.org/learn/interactive-python-1






            share|improve this answer









            $endgroup$



            There is a good class on Coursera for interactive game programming in Python by some professors from Rice University, which I used when I started learning Python. It's really good at introducing the ideas very gradually, but eventually creates a pretty sophisticated game.



            There might be some ideas you can get from the course, or maybe you could do an inverted classroom?
            https://www.coursera.org/learn/interactive-python-1







            share|improve this answer












            share|improve this answer



            share|improve this answer










            answered Jan 12 at 4:43









            Allen WangAllen Wang

            1345




            1345























                1












                $begingroup$

                What about a circuit python project to finish off the semester? There's no GUI as such, but you can show them a cool demo, then have them learn codes that builds towards some kind of cool interactive project. Doesn't have to be big or expensive, but lets them truly make something tangible out of their code. An Arduino was really the first thing that got me motivated to stick with programming.






                share|improve this answer









                $endgroup$









                • 1




                  $begingroup$
                  Please say more about "circuit python". An example would be good. What is a "cool" demo or a "cool interactive project"?
                  $endgroup$
                  – Buffy
                  Jan 12 at 20:36










                • $begingroup$
                  Depends on the scope of the class, so I'd say it's up to the OP. My point really is that building something practical, and hands on, can help ground programming. Turning LEDs different colors at the touch of a button, or having them activate based on a particular level of sound or light, can help turn more abstract concepts into something tangible.
                  $endgroup$
                  – Britton
                  Jan 13 at 15:43
















                1












                $begingroup$

                What about a circuit python project to finish off the semester? There's no GUI as such, but you can show them a cool demo, then have them learn codes that builds towards some kind of cool interactive project. Doesn't have to be big or expensive, but lets them truly make something tangible out of their code. An Arduino was really the first thing that got me motivated to stick with programming.






                share|improve this answer









                $endgroup$









                • 1




                  $begingroup$
                  Please say more about "circuit python". An example would be good. What is a "cool" demo or a "cool interactive project"?
                  $endgroup$
                  – Buffy
                  Jan 12 at 20:36










                • $begingroup$
                  Depends on the scope of the class, so I'd say it's up to the OP. My point really is that building something practical, and hands on, can help ground programming. Turning LEDs different colors at the touch of a button, or having them activate based on a particular level of sound or light, can help turn more abstract concepts into something tangible.
                  $endgroup$
                  – Britton
                  Jan 13 at 15:43














                1












                1








                1





                $begingroup$

                What about a circuit python project to finish off the semester? There's no GUI as such, but you can show them a cool demo, then have them learn codes that builds towards some kind of cool interactive project. Doesn't have to be big or expensive, but lets them truly make something tangible out of their code. An Arduino was really the first thing that got me motivated to stick with programming.






                share|improve this answer









                $endgroup$



                What about a circuit python project to finish off the semester? There's no GUI as such, but you can show them a cool demo, then have them learn codes that builds towards some kind of cool interactive project. Doesn't have to be big or expensive, but lets them truly make something tangible out of their code. An Arduino was really the first thing that got me motivated to stick with programming.







                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered Jan 12 at 4:10









                BrittonBritton

                111




                111








                • 1




                  $begingroup$
                  Please say more about "circuit python". An example would be good. What is a "cool" demo or a "cool interactive project"?
                  $endgroup$
                  – Buffy
                  Jan 12 at 20:36










                • $begingroup$
                  Depends on the scope of the class, so I'd say it's up to the OP. My point really is that building something practical, and hands on, can help ground programming. Turning LEDs different colors at the touch of a button, or having them activate based on a particular level of sound or light, can help turn more abstract concepts into something tangible.
                  $endgroup$
                  – Britton
                  Jan 13 at 15:43














                • 1




                  $begingroup$
                  Please say more about "circuit python". An example would be good. What is a "cool" demo or a "cool interactive project"?
                  $endgroup$
                  – Buffy
                  Jan 12 at 20:36










                • $begingroup$
                  Depends on the scope of the class, so I'd say it's up to the OP. My point really is that building something practical, and hands on, can help ground programming. Turning LEDs different colors at the touch of a button, or having them activate based on a particular level of sound or light, can help turn more abstract concepts into something tangible.
                  $endgroup$
                  – Britton
                  Jan 13 at 15:43








                1




                1




                $begingroup$
                Please say more about "circuit python". An example would be good. What is a "cool" demo or a "cool interactive project"?
                $endgroup$
                – Buffy
                Jan 12 at 20:36




                $begingroup$
                Please say more about "circuit python". An example would be good. What is a "cool" demo or a "cool interactive project"?
                $endgroup$
                – Buffy
                Jan 12 at 20:36












                $begingroup$
                Depends on the scope of the class, so I'd say it's up to the OP. My point really is that building something practical, and hands on, can help ground programming. Turning LEDs different colors at the touch of a button, or having them activate based on a particular level of sound or light, can help turn more abstract concepts into something tangible.
                $endgroup$
                – Britton
                Jan 13 at 15:43




                $begingroup$
                Depends on the scope of the class, so I'd say it's up to the OP. My point really is that building something practical, and hands on, can help ground programming. Turning LEDs different colors at the touch of a button, or having them activate based on a particular level of sound or light, can help turn more abstract concepts into something tangible.
                $endgroup$
                – Britton
                Jan 13 at 15:43











                1












                $begingroup$

                There is little point these days in making a GUI program, except in the most rare cases, especially with Python. In the age of the internet, most programs are best served as web apps. I expect this will be most relevant to your students' interests as well. For Python I would suggest starting with Flask or Django. There are good Django tutorials here:




                • https://docs.djangoproject.com/en/2.1/intro/tutorial01/


                • https://tutorial.djangogirls.org/en/



                And I like this Flask one:




                • https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world


                All of these should show you how to make a basic app, which has a GUI in the form of a web interface.



                You might also consider something more visual in the form of basic data analysis and plotting with Jupyter notebooks.






                share|improve this answer











                $endgroup$









                • 3




                  $begingroup$
                  This requires the students to understand all kinds of web techniques, most notably HTTP and HTML, which might be too advanced for freshmen students (without being the actual subject of the course). It makes more sense at a later stage of the curriculum when they already learned about network stuff.
                  $endgroup$
                  – Bergi
                  Jan 12 at 17:57












                • $begingroup$
                  How is a web app not a GUI? The client is quite graphic usually.
                  $endgroup$
                  – Mast
                  Jan 12 at 21:22












                • $begingroup$
                  @mast with Python? the web app would be a GUI app (if its actually an app not an interface) but its not event driven like a standalone GUI app would be (or rather to make it event driven you would have to switch to Javascript) - so it would end up not teaching the students the same lessons (or language). I wouldn't say standalone GUIs are rare - remember cell phone games and tools as well as office applications are still typically stand-alones. Just depends on the field (like I will probably never write another serious webapp but GUIs? yeah, all the time in C# with python backend)
                  $endgroup$
                  – JGreenwell
                  Jan 13 at 4:05










                • $begingroup$
                  @JGreenwell thats what I was getting at. Creating the actual GUI for those apps is often not done with Python. The skills to build a web app may be outside the scope of a freshman curriculum, but you should not forget that this is probably why those students signed up for Computer Science in the first place; to learn mainstream app building techniques. I doubt they signed up because they wanted to learn algorithms. And both Flask and Django are easy enough to learn from the tutorials I posted, I taught myself both using these.
                  $endgroup$
                  – user5359531
                  Jan 13 at 10:58


















                1












                $begingroup$

                There is little point these days in making a GUI program, except in the most rare cases, especially with Python. In the age of the internet, most programs are best served as web apps. I expect this will be most relevant to your students' interests as well. For Python I would suggest starting with Flask or Django. There are good Django tutorials here:




                • https://docs.djangoproject.com/en/2.1/intro/tutorial01/


                • https://tutorial.djangogirls.org/en/



                And I like this Flask one:




                • https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world


                All of these should show you how to make a basic app, which has a GUI in the form of a web interface.



                You might also consider something more visual in the form of basic data analysis and plotting with Jupyter notebooks.






                share|improve this answer











                $endgroup$









                • 3




                  $begingroup$
                  This requires the students to understand all kinds of web techniques, most notably HTTP and HTML, which might be too advanced for freshmen students (without being the actual subject of the course). It makes more sense at a later stage of the curriculum when they already learned about network stuff.
                  $endgroup$
                  – Bergi
                  Jan 12 at 17:57












                • $begingroup$
                  How is a web app not a GUI? The client is quite graphic usually.
                  $endgroup$
                  – Mast
                  Jan 12 at 21:22












                • $begingroup$
                  @mast with Python? the web app would be a GUI app (if its actually an app not an interface) but its not event driven like a standalone GUI app would be (or rather to make it event driven you would have to switch to Javascript) - so it would end up not teaching the students the same lessons (or language). I wouldn't say standalone GUIs are rare - remember cell phone games and tools as well as office applications are still typically stand-alones. Just depends on the field (like I will probably never write another serious webapp but GUIs? yeah, all the time in C# with python backend)
                  $endgroup$
                  – JGreenwell
                  Jan 13 at 4:05










                • $begingroup$
                  @JGreenwell thats what I was getting at. Creating the actual GUI for those apps is often not done with Python. The skills to build a web app may be outside the scope of a freshman curriculum, but you should not forget that this is probably why those students signed up for Computer Science in the first place; to learn mainstream app building techniques. I doubt they signed up because they wanted to learn algorithms. And both Flask and Django are easy enough to learn from the tutorials I posted, I taught myself both using these.
                  $endgroup$
                  – user5359531
                  Jan 13 at 10:58
















                1












                1








                1





                $begingroup$

                There is little point these days in making a GUI program, except in the most rare cases, especially with Python. In the age of the internet, most programs are best served as web apps. I expect this will be most relevant to your students' interests as well. For Python I would suggest starting with Flask or Django. There are good Django tutorials here:




                • https://docs.djangoproject.com/en/2.1/intro/tutorial01/


                • https://tutorial.djangogirls.org/en/



                And I like this Flask one:




                • https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world


                All of these should show you how to make a basic app, which has a GUI in the form of a web interface.



                You might also consider something more visual in the form of basic data analysis and plotting with Jupyter notebooks.






                share|improve this answer











                $endgroup$



                There is little point these days in making a GUI program, except in the most rare cases, especially with Python. In the age of the internet, most programs are best served as web apps. I expect this will be most relevant to your students' interests as well. For Python I would suggest starting with Flask or Django. There are good Django tutorials here:




                • https://docs.djangoproject.com/en/2.1/intro/tutorial01/


                • https://tutorial.djangogirls.org/en/



                And I like this Flask one:




                • https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world


                All of these should show you how to make a basic app, which has a GUI in the form of a web interface.



                You might also consider something more visual in the form of basic data analysis and plotting with Jupyter notebooks.







                share|improve this answer














                share|improve this answer



                share|improve this answer








                edited Jan 12 at 13:08

























                answered Jan 12 at 12:52









                user5359531user5359531

                1112




                1112








                • 3




                  $begingroup$
                  This requires the students to understand all kinds of web techniques, most notably HTTP and HTML, which might be too advanced for freshmen students (without being the actual subject of the course). It makes more sense at a later stage of the curriculum when they already learned about network stuff.
                  $endgroup$
                  – Bergi
                  Jan 12 at 17:57












                • $begingroup$
                  How is a web app not a GUI? The client is quite graphic usually.
                  $endgroup$
                  – Mast
                  Jan 12 at 21:22












                • $begingroup$
                  @mast with Python? the web app would be a GUI app (if its actually an app not an interface) but its not event driven like a standalone GUI app would be (or rather to make it event driven you would have to switch to Javascript) - so it would end up not teaching the students the same lessons (or language). I wouldn't say standalone GUIs are rare - remember cell phone games and tools as well as office applications are still typically stand-alones. Just depends on the field (like I will probably never write another serious webapp but GUIs? yeah, all the time in C# with python backend)
                  $endgroup$
                  – JGreenwell
                  Jan 13 at 4:05










                • $begingroup$
                  @JGreenwell thats what I was getting at. Creating the actual GUI for those apps is often not done with Python. The skills to build a web app may be outside the scope of a freshman curriculum, but you should not forget that this is probably why those students signed up for Computer Science in the first place; to learn mainstream app building techniques. I doubt they signed up because they wanted to learn algorithms. And both Flask and Django are easy enough to learn from the tutorials I posted, I taught myself both using these.
                  $endgroup$
                  – user5359531
                  Jan 13 at 10:58
















                • 3




                  $begingroup$
                  This requires the students to understand all kinds of web techniques, most notably HTTP and HTML, which might be too advanced for freshmen students (without being the actual subject of the course). It makes more sense at a later stage of the curriculum when they already learned about network stuff.
                  $endgroup$
                  – Bergi
                  Jan 12 at 17:57












                • $begingroup$
                  How is a web app not a GUI? The client is quite graphic usually.
                  $endgroup$
                  – Mast
                  Jan 12 at 21:22












                • $begingroup$
                  @mast with Python? the web app would be a GUI app (if its actually an app not an interface) but its not event driven like a standalone GUI app would be (or rather to make it event driven you would have to switch to Javascript) - so it would end up not teaching the students the same lessons (or language). I wouldn't say standalone GUIs are rare - remember cell phone games and tools as well as office applications are still typically stand-alones. Just depends on the field (like I will probably never write another serious webapp but GUIs? yeah, all the time in C# with python backend)
                  $endgroup$
                  – JGreenwell
                  Jan 13 at 4:05










                • $begingroup$
                  @JGreenwell thats what I was getting at. Creating the actual GUI for those apps is often not done with Python. The skills to build a web app may be outside the scope of a freshman curriculum, but you should not forget that this is probably why those students signed up for Computer Science in the first place; to learn mainstream app building techniques. I doubt they signed up because they wanted to learn algorithms. And both Flask and Django are easy enough to learn from the tutorials I posted, I taught myself both using these.
                  $endgroup$
                  – user5359531
                  Jan 13 at 10:58










                3




                3




                $begingroup$
                This requires the students to understand all kinds of web techniques, most notably HTTP and HTML, which might be too advanced for freshmen students (without being the actual subject of the course). It makes more sense at a later stage of the curriculum when they already learned about network stuff.
                $endgroup$
                – Bergi
                Jan 12 at 17:57






                $begingroup$
                This requires the students to understand all kinds of web techniques, most notably HTTP and HTML, which might be too advanced for freshmen students (without being the actual subject of the course). It makes more sense at a later stage of the curriculum when they already learned about network stuff.
                $endgroup$
                – Bergi
                Jan 12 at 17:57














                $begingroup$
                How is a web app not a GUI? The client is quite graphic usually.
                $endgroup$
                – Mast
                Jan 12 at 21:22






                $begingroup$
                How is a web app not a GUI? The client is quite graphic usually.
                $endgroup$
                – Mast
                Jan 12 at 21:22














                $begingroup$
                @mast with Python? the web app would be a GUI app (if its actually an app not an interface) but its not event driven like a standalone GUI app would be (or rather to make it event driven you would have to switch to Javascript) - so it would end up not teaching the students the same lessons (or language). I wouldn't say standalone GUIs are rare - remember cell phone games and tools as well as office applications are still typically stand-alones. Just depends on the field (like I will probably never write another serious webapp but GUIs? yeah, all the time in C# with python backend)
                $endgroup$
                – JGreenwell
                Jan 13 at 4:05




                $begingroup$
                @mast with Python? the web app would be a GUI app (if its actually an app not an interface) but its not event driven like a standalone GUI app would be (or rather to make it event driven you would have to switch to Javascript) - so it would end up not teaching the students the same lessons (or language). I wouldn't say standalone GUIs are rare - remember cell phone games and tools as well as office applications are still typically stand-alones. Just depends on the field (like I will probably never write another serious webapp but GUIs? yeah, all the time in C# with python backend)
                $endgroup$
                – JGreenwell
                Jan 13 at 4:05












                $begingroup$
                @JGreenwell thats what I was getting at. Creating the actual GUI for those apps is often not done with Python. The skills to build a web app may be outside the scope of a freshman curriculum, but you should not forget that this is probably why those students signed up for Computer Science in the first place; to learn mainstream app building techniques. I doubt they signed up because they wanted to learn algorithms. And both Flask and Django are easy enough to learn from the tutorials I posted, I taught myself both using these.
                $endgroup$
                – user5359531
                Jan 13 at 10:58






                $begingroup$
                @JGreenwell thats what I was getting at. Creating the actual GUI for those apps is often not done with Python. The skills to build a web app may be outside the scope of a freshman curriculum, but you should not forget that this is probably why those students signed up for Computer Science in the first place; to learn mainstream app building techniques. I doubt they signed up because they wanted to learn algorithms. And both Flask and Django are easy enough to learn from the tutorials I posted, I taught myself both using these.
                $endgroup$
                – user5359531
                Jan 13 at 10:58













                1












                $begingroup$

                On command line



                To make command line programs make sense, you need to first teach Unix (Or another OS with a workable command line: VMS, Amiga-dos, sorry I can't think of any others that are still relevant).



                When one can see the value in a powerful command line, where one can complete tasks much more quickly and with less pain, then it becomes obvious why one would write ones own command line programs.



                On GUI



                Yes for graphical programming, but this is not GUI programming.



                I have used python turtle, it aids learning because it gives immediate feedback. I have used it to teach the basics, in schools. It could also be used to teach algorithms: First teach basics, then add drawing of data sets, then …



                UnPlugged



                Also consider teaching some of it unplugged. You can teach algorithms, by having the students be the data, by having a student direct, by having a student explain, by using props e.g. backs of cards, white boards, paper, mini-whiteboards, …



                See https://csunplugged.org/en/ for some ideas. This site is aimed at primary school teachers, but most of it can be adapted.






                share|improve this answer









                $endgroup$


















                  1












                  $begingroup$

                  On command line



                  To make command line programs make sense, you need to first teach Unix (Or another OS with a workable command line: VMS, Amiga-dos, sorry I can't think of any others that are still relevant).



                  When one can see the value in a powerful command line, where one can complete tasks much more quickly and with less pain, then it becomes obvious why one would write ones own command line programs.



                  On GUI



                  Yes for graphical programming, but this is not GUI programming.



                  I have used python turtle, it aids learning because it gives immediate feedback. I have used it to teach the basics, in schools. It could also be used to teach algorithms: First teach basics, then add drawing of data sets, then …



                  UnPlugged



                  Also consider teaching some of it unplugged. You can teach algorithms, by having the students be the data, by having a student direct, by having a student explain, by using props e.g. backs of cards, white boards, paper, mini-whiteboards, …



                  See https://csunplugged.org/en/ for some ideas. This site is aimed at primary school teachers, but most of it can be adapted.






                  share|improve this answer









                  $endgroup$
















                    1












                    1








                    1





                    $begingroup$

                    On command line



                    To make command line programs make sense, you need to first teach Unix (Or another OS with a workable command line: VMS, Amiga-dos, sorry I can't think of any others that are still relevant).



                    When one can see the value in a powerful command line, where one can complete tasks much more quickly and with less pain, then it becomes obvious why one would write ones own command line programs.



                    On GUI



                    Yes for graphical programming, but this is not GUI programming.



                    I have used python turtle, it aids learning because it gives immediate feedback. I have used it to teach the basics, in schools. It could also be used to teach algorithms: First teach basics, then add drawing of data sets, then …



                    UnPlugged



                    Also consider teaching some of it unplugged. You can teach algorithms, by having the students be the data, by having a student direct, by having a student explain, by using props e.g. backs of cards, white boards, paper, mini-whiteboards, …



                    See https://csunplugged.org/en/ for some ideas. This site is aimed at primary school teachers, but most of it can be adapted.






                    share|improve this answer









                    $endgroup$



                    On command line



                    To make command line programs make sense, you need to first teach Unix (Or another OS with a workable command line: VMS, Amiga-dos, sorry I can't think of any others that are still relevant).



                    When one can see the value in a powerful command line, where one can complete tasks much more quickly and with less pain, then it becomes obvious why one would write ones own command line programs.



                    On GUI



                    Yes for graphical programming, but this is not GUI programming.



                    I have used python turtle, it aids learning because it gives immediate feedback. I have used it to teach the basics, in schools. It could also be used to teach algorithms: First teach basics, then add drawing of data sets, then …



                    UnPlugged



                    Also consider teaching some of it unplugged. You can teach algorithms, by having the students be the data, by having a student direct, by having a student explain, by using props e.g. backs of cards, white boards, paper, mini-whiteboards, …



                    See https://csunplugged.org/en/ for some ideas. This site is aimed at primary school teachers, but most of it can be adapted.







                    share|improve this answer












                    share|improve this answer



                    share|improve this answer










                    answered Jan 13 at 16:40









                    ctrl-alt-delorctrl-alt-delor

                    7,40131447




                    7,40131447























                        1












                        $begingroup$

                        I teach event-driven GUI programming in Java. This requires machinery. First of all, students need to be good at writing functions and procedural programs. Secondly, they need to understand polymorphism and inheritance, as these are vital tools. So, we are beyond the range of beginners here.



                        However, if you teaching Java, GUIs are a compelling use case for the whole inheritance mechanism. Java8 lambdas make the writing of callbacks simpler and more fun. I use the JavaFX framework for this purpose. If you are doing this in java11, it is tricky to get set up and configured.



                        I don't see this as a game for novices.






                        share|improve this answer









                        $endgroup$


















                          1












                          $begingroup$

                          I teach event-driven GUI programming in Java. This requires machinery. First of all, students need to be good at writing functions and procedural programs. Secondly, they need to understand polymorphism and inheritance, as these are vital tools. So, we are beyond the range of beginners here.



                          However, if you teaching Java, GUIs are a compelling use case for the whole inheritance mechanism. Java8 lambdas make the writing of callbacks simpler and more fun. I use the JavaFX framework for this purpose. If you are doing this in java11, it is tricky to get set up and configured.



                          I don't see this as a game for novices.






                          share|improve this answer









                          $endgroup$
















                            1












                            1








                            1





                            $begingroup$

                            I teach event-driven GUI programming in Java. This requires machinery. First of all, students need to be good at writing functions and procedural programs. Secondly, they need to understand polymorphism and inheritance, as these are vital tools. So, we are beyond the range of beginners here.



                            However, if you teaching Java, GUIs are a compelling use case for the whole inheritance mechanism. Java8 lambdas make the writing of callbacks simpler and more fun. I use the JavaFX framework for this purpose. If you are doing this in java11, it is tricky to get set up and configured.



                            I don't see this as a game for novices.






                            share|improve this answer









                            $endgroup$



                            I teach event-driven GUI programming in Java. This requires machinery. First of all, students need to be good at writing functions and procedural programs. Secondly, they need to understand polymorphism and inheritance, as these are vital tools. So, we are beyond the range of beginners here.



                            However, if you teaching Java, GUIs are a compelling use case for the whole inheritance mechanism. Java8 lambdas make the writing of callbacks simpler and more fun. I use the JavaFX framework for this purpose. If you are doing this in java11, it is tricky to get set up and configured.



                            I don't see this as a game for novices.







                            share|improve this answer












                            share|improve this answer



                            share|improve this answer










                            answered Jan 16 at 19:35









                            ncmathsadistncmathsadist

                            1,723212




                            1,723212






























                                draft saved

                                draft discarded




















































                                Thanks for contributing an answer to Computer Science Educators Stack Exchange!


                                • Please be sure to answer the question. Provide details and share your research!

                                But avoid …



                                • Asking for help, clarification, or responding to other answers.

                                • Making statements based on opinion; back them up with references or personal experience.


                                Use MathJax to format equations. MathJax reference.


                                To learn more, see our tips on writing great answers.




                                draft saved


                                draft discarded














                                StackExchange.ready(
                                function () {
                                StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcseducators.stackexchange.com%2fquestions%2f5358%2fany-simple-python-gui-projects-for-beginner-novice-programming-students%23new-answer', 'question_page');
                                }
                                );

                                Post as a guest















                                Required, but never shown





















































                                Required, but never shown














                                Required, but never shown












                                Required, but never shown







                                Required, but never shown

































                                Required, but never shown














                                Required, but never shown












                                Required, but never shown







                                Required, but never shown







                                -

                                Popular posts from this blog

                                Human spaceflight

                                Image
                                Human spaceflight From Wikipedia, the free encyclopedia Jump to navigation Jump to search "Space traveler" redirects here. For other uses, see Space traveler (disambiguation). @media all and (max-width:720px){.mw-parser-output .tmulti>.thumbinner{width:100%!important;max-width:none!important}.mw-parser-output .tmulti .tsingle{float:none!important;max-width:none!important;width:100%!important;text-align:center}} Apollo 11 crewmember Buzz Aldrin on the Moon, 1969 International Space Station crewmember Tracy Caldwell Dyson views the Earth, 2010 Space Shuttle Discovery heads into space with a crew aboard, STS-121 in 2006 Inside a space suit on the Canadarm, 1993 Human spaceflight (also referred to as crewed spaceflight or manned spaceflight ) is space travel with a crew or passengers aboard the spacecraft. Spacecraft carrying people may be operated directly, by human crew, or it may be e
                                Read more

                                Can not write log (Is /dev/pts mounted?) - openpty in Ubuntu-on-Windows?

                                Image
                                0 1 What exactly does the error message beginning with E: mean? I assume it has to do with the file structure on Ubuntu-on-Windows, but what exactly? The following package was automatically installed and is no longer required: os-prober Use 'apt-get autoremove' to remove it. The following extra packages will be installed: libxslt1.1 The following NEW packages will be installed: libxslt1.1 xmlstarlet 0 upgraded, 2 newly installed, 0 to remove and 0 not upgraded. Need to get 435 kB of archives. After this operation, 1023 kB of additional disk space will be used. Get:1 http://archive.ubuntu.com/ubuntu/ trusty/main libxslt1.1 amd64 1.1.28-2build1 [145 kB] Get:2 http://archive.ubuntu.com/ubuntu/ trusty/universe xmlstarlet amd64 1.5.0-1 [290 kB]
                                Read more

                                File:DeusFollowingSea.jpg

                                Image
                                File:DeusFollowingSea.jpg From Wikipedia, the free encyclopedia Jump to navigation Jump to search File File history File usage No higher resolution available. DeusFollowingSea.jpg ‎ (238 × 211 pixels, file size: 12 KB, MIME type: image/jpeg ) Summary [ edit ] Media data and Non-free use rationale Description Cover art of the Deus CD Following Sea Author or copyright owner Deus Source (WP:NFCC#4) rocksucker.co.uk Date of publication 2012 Use in article (WP:NFCC#7) Following Sea Purpose of use in article (WP:NFCC#8) to serve as the primary means of visual identification at the top of the article dedicated to the work in question. Not replaceable with free media because (WP:NFCC#1) n.a. Minimal use (WP:NFCC#3) Low res image used in infobox of the article on the album Respect for commercial opportunities (WP:NFCC#2) n.a. Fair use Fair use of co
                                Read more