Mentoring middle schoolers help

Hello! I mentor middle school teams and I was wondering if the new graphically programming is better than the original for teaching them. Thank you for the help:o

Most middle schoolers would probably find the graphical functions to be easier to understand if they are first time programmers.
At a certain point though they will want to make the switch to text programming. I guess with the natural language this wouldn’t be that hard as they are pretty much the same functions.
Then, they just have to transition from natural to “real” programming.
If you went in that sequence, programming probably wouldn’t be very intimidating at all.

On the other hand, if they do have programming experience, it might be best to just get them straight into the regular stuff.

I help mentor as well. Please help


I learned to write Java, like real Java when I was 12 and I know that many people have learned to code at much younger ages. For example there’s like a 12-13 year old ish kid that goes to my university and is at the same level as me in the Computer Science program.

For real.

Why add the extra transitional step? I think you’ll find that kids of that age are so sponge-like that they can and will learn pretty much anything you teach them properly.

That and kids these days aren’t exactly afraid or unaware of computers and technology. They’ll probably eat it up if properly motivated. Show them what’s possible first then start teaching code, real code while continuing to link it directly back to making robots do things.

:eek:Welp, I feel irrelevant.

I was originally going to say that you should start teaching with EasyC, but I think you’re right. Kids who genuinely care will be able to get the basics of programming robots down easily. The trick, of course, as Cody mentioned, will be to teach properly. I would, however, recommend starting with Scratch, which teaches basic programming logic in a drag-n-drop environment.

Are you using RobotC, EasyC or what?

I looked at EasyC last year and I didn’t feel it was very much easier to use/teach than RobotC with its “normal” text-based code. It’s possible that my poor eyesight made it hard for me to see all the little icons, so perhaps that contributed to my ambivalence toward it.

The new RobotC comes with a graphical, drag-and-drop version. I played with it just a little bit, but I can see where starting kids off with the RobotC graphical version might help, at least at first. If nothing else, the drag-and-drop feature helps them avoid making typing mistakes which often involve omitting the curly brackets. The coolest thing is that it has the ability to convert the graphical into a text mode, so as the kids advance, they can progress to text-only programming. The graphical interface appears to be somewhat limiting, so for more advanced features, I think you probably need to use the text-based version. Unfortunately, as far as I know, you can’t go from the text based version back to the graphical, so that’s something of a one-way street.

It’s probably like anything else: you will find some kids prefer the graphical stuff and others who prefer the text-based approach.

I know right, the kids dad did it right. He’s a CS guy and just taught his kid early and pushed to get the kid into college quickly.

This is a really weird thing people get wrong all the freaking time.

People think that kids are somehow less capable than adults esp. when it comes learning. The opposite it true. Kids learn better than adults and as someone who was a kid and is now an adult, I can confirm this.

Luckily as a kid I spent plenty of time actually learning to write code, learning 2D/3D art/animation/etc and everything I could about computers, engineering and robots. It makes me very sad when I see kids spend all their free time doing extremely unproductive things, like playing video games (and yes I did plenty of that too) and when I ask them why they aren’t learning they tell me something along the lines of “that’s what school is for.”

School, or I should say the American educational system is beyond [INSERT NEGATIVE WORDS HERE]ed right now. The skills you leave with are a joke, and that’s one of many reasons I love robots so much.

You take vitamin supplements when you know your diet isn’t giving your body everything it needs.

You build robots when you know your school isn’t giving your brain everything it needs.

Teach the freaking kids real C using ROBOTC or EasyC.

Just do a good job, lots of examples, short lectures, let them try it (them writing their own code) as much as possible. DO NOT sit there and have them copy exactly what you do and expect good results.

Also watch this and/or this.


I recommend EasyC, That’s what I learned my first year.

We’ve always done Robot C and it’s worked out well.

Syntax is something to help the kids with each time as well as logically going through the flow.

They usually start with one big long function and then you can teach them about looping around, calling functions for common things when writing autonomous routines. The graphical part can help with the loops and such but it can also start hindering it too.

Usually we have one or two kids per team really interested in the programming end. Getting autonomous field time is critical in developing their skills. Once they have the programming bug, start with control loops and then debugging techniques.

Here are some of our 6th and 7th grade teams line followers from our spring class… They got a bit better by the end. One team made it all the way through the challenge.

One technique I used last year that helped a lot with autonomous (using RobotC). I sat down with the kids and we worked through the types of independent movements the robot needed to do and what its max allowable motions/sensor ranges were, etc… Then we wrote a “Defined Function” for each type of movement.

For example, this was one of the defined functions: DriveForwardSpeedDistance(Speed, Distance)

After writing the defined function, the kids merely had to enter the values later in the code when they called that function. So, for example
DriveForwardSpeedDistance(80, 14);
would cause the robot to drive at 80/127 its max speed, and travel 14 inches before it stopped. We did that with all the turns, arm raising, etc.

It puzzles me that kids are usually not taught about Defined Functions until later in their “careers”. By breaking down the motions into little segments, it helps prevent them from suffering cognitive overload, and it seemed to work out well for them. It impressed the judges that they even knew what Defined Functions were, never mind how to actually use them.

That was a very smart idea the way they did it at my school first year with robotics we use easy c and they wanted us to do simple programs. One example knock the big all over or push a buckyball. If you have robot c you could use natrual code. If you do not know what natrual code here is an example we use it in our vex class.


Yeah, I think the extra transitional step isn’t really that useful. In the future, when the kids program, they’ll be working with real code. I used to do Lego Mindstorms, and the graphical programming confused me so much. Real code isn’t too hard to learn, especially with kids. I don’t believe graphical programming will make it any easier, especially if the kids will have to “unlearn” it in the future when they learn real programming.

Of course, basic understanding of programming really helps if the kids start out with RobotC.

Thank you for all of the input. The middle schoolers will probably be learning RobotC for the main reason, when they become more advance they will be able to program. If I may ask though, what is the best way to teach them the simple basics of teamwork?:o

How to teach teamwork?

That’s not teachable, it’s incorrigible.

You’ve got computers, robots and a bunch of middle schoolers. Awesome mix, now you have to herd them into small groups for say 3-4, maybe give each group a computer and hopefully a robot.

Actually just divide the kids by floor(computers, robots) and throw the remainder into other groups.

From there I’d give them a task, something simple to start off with, like wire up the motors and program them to go.

Have them follow you, using a projector if at all possible, for just the first assignment. Write something dead simple like…

    motor[x] = getJoystickThingy(y);
    motor[z] = getJoystickThingy(w);

Pick up a joystick and demonstrate the awesomeness of driving a robot with that code, at this point the kids will go nuts - let them.

Have them do it, then after allowing them to play a little have them settle down and explain the code in detail.

It’s a loop, the code runs over and over, assigning the value of the joystick to a motor, etc.

Then build from there, teach them conditionals, variables, etc.

Once they have enough tools, task the groups with something neat and let them go, at this point you move from group to group answering questions and helping them when they get stuck.

They’ll naturally work together in this format because you’ve set it up that way. If some kids try to hog a part of this too much, do something about it.