Slashdot Mirror

Games, at the very least. You say music videos, but at what quality. And music videos are generally the smallest of video files. Let's plays, not to mention shows and movies are generally larger. Tutorial videos? Like ones on how to use Unity or the "Processing" environment?

Taking apart a computer and programming are two orthogonal skills -- someone might be great at one and terrible at the other.

I've successfully used Basic4GL to teach basic programming, graphics, and algebra concepts to underperforming 6th graders. They really loved the exercise of drawing a spaceship first on graph paper and then on the computer using simple graphics commands. Basic4GL is great because it has built in sound, graphics, etc.

I will suggest 3 other things

1) Teach the Processing computer language. It's graphical, easy to start with, and mature.
2) Teach the Arduino. Build a simple circuit or a very simple robot with two servos. Any Arduino workshop devolves pleasantly into students tinkering with stuff.
3) Teach Python

I'll caution against Python because the text only interaction may bore them (even though I've taught this language before).

After being used to more powerful IDEs I was at first unimpressed with the Processing IDE. However, the more I mess around with it, it's not all that bad. It's what the Arduino's IDE is based on and where I was first introduced to it.

I could see it being a very good introduction to programming. Simple interface, easy to set up and tons of examples and tutorials. Write code, click "run".

I teach 3D graphics, programming and compositing & postproduction at a university of applied sciences. Every year, our students build machines for the annual Roboexotica cocktail robotics festival. I usually accompany the students at the event and fix their machines on the exhibition floor - with soldering irons, lots of tape and a notebook. Since most of the student machines are created in a hurry, their Processing and Arduino code usually has errors. Sometimes I find myself sitting on the floor between alcohol canisters, pumps and wires, debugging stuff while drunk people stumble around. :-)

I'm a Meteor developer, using full-stack Javascript 100% of the time... Node.js, MongoDB, and jQuery are my stock in trade. If you're not familiar, Meteor is basically 'Javascript on Rails'. And, in my experience, everything in the article is spot on. As to the jaw-dropping abilities...

- developing in a unified language has increased my productivity 5x to 10x. I get done in a weekend what used to take me a month or more to do in PHP or C#. That's jaw dropping from a business sense, and has allowed me to completely change my business structure and approach. Frameworks like Meteor and Derby are going to win out on productivity gains alone. I can go from an initial client meeting to launching a beta of a multi-user application in a weekend.

- remember that javascript is based on actionscript, based on scheme, based on lisp. When you have your client, server, and database all using a functional language, you can start creating UI elements as monad operations on datastore elements. No objects ever on the heap. Just chained functions from database to server to client to UI. Among other things, this allows for things like reactive templates, demonstrated in the following screencast:

http://meteor.com/screencast

- besides the reactive templates, sharing of libraries between client and server makes every Meteor application theoretically capable of becoming a peer-to-peer distributed application. No PHP or Ruby or C# web application can do that. In theory, you could bundle the node.js libraries themselves into the client, and have each served client become a new peer-to-peer node.

- this allows mesh networking functionality, with monad operations defining computations between and through nodes. Think of it like routing protocols, but with computations. Lots of distributed computing possibilities here, obviously. More importantly is bandwidth usage, offline data synchronization, and the like. Instead of going to a data center to get the latest package updates, applications will be able to query neighbor nodes. Think IPv6 functionality, mesh networking, and being able to query data states from intermediary peers. The people in the Meteor dev community are actively working on things ranging from meters for smart energy grids to real-time bee pollination tracking.

Those technical details aside, the underlying reason why pure javascript can result in jaw-dropping applications is because, at it's core, javascript is a functional language, in the manner of lisp (if you know how to use the lambda calculus). It's lisp for the web (or scheme for the web, if you prefer). And putting it on both the server and client and database allows developers to do crazy monad calculations and method chaining. The monads will update and recalculate themselves in real time, as the underlying data changes. The end result is reactive templates and data-driven animations and UI elements.

If you want a better understanding how this is going to play out, check out the D3 visualization library here:

https://github.com/mbostock/d3/wiki/Gallery

Then, imagine all those visualizations used to create applications like in Processing:

http://processing.org/exhibition/

That's the direction this stuff is headed in. If you want to see some real examples in action, consider the interactives on the New York Times

http://www.nytimes.com/interactive/2012/05/17/business/dealbook/how-the-facebook-offering-compares.html?_r=0
http://www.nytimes.com/interactive/2012/02/13/us/politics/2013-budget-proposal-graphic.html

Before making the big leap into opengl and such, you can make a simpler step into fully programmatic computer animations, either with Processing or Happy Fun Coding.

Not familiar with computational design? Check out some of the examples on the processing gallery.

Not familiar with computational design? Check out some of the examples on the processing gallery.

Not familiar with computational design? Check out some of the examples on the processing gallery.

Yo, you must have never played with a Kinect/Xtion, Bee...
Try processing with SimpleOpenNI lib for a quick entry, or
see here for some examples: http://www.openprocessing.org/search/?q=kinect (or look online for tuts).
That's nice for prototyping as well, btw.

C U in minority report 2.0

Processing would be an option. It's basically Java, but gives immediate feedback like s script language, and it's visual, which makes it fun to learn because you see immediate results, and if you want to make games it may be a good fit.

http://www.processing.org/
http://www.openprocessing.org/

It is easier for a child when something is made to look easy, and the results are made to look fascinating. The environment and the mentor are paramount. But this has become harder recently because everything has advanced so much since the Nintendo Entertainment System days. Also it doesn't help that platforms like the iPhone are hard to develop for (the closed garden hurdles, so to speak).

Games used to be a good genre but now kids are playing MW3 and GW3 so it's increasingly harder to convince them they can build something similar. Games are still a good place to start, but only if you have the right tools to do it.

Web programming is good because HTML and CSS is rather straightforward, and kids will be able to edit and publish their own web site. They can get into javascript and server admin stuff too. The reward for having the site will be the biggest hurdle, since most online presence missions are done better piggy-backing on facebook or word press.

Graphics programming is good because it has to do with math, and math is something kids are already force-fed at school. If you can demonstrate how math is used to build real things, and by learning graphics programming that the child can get straight As by way of beating the curve, kids are often all for it. Great place to start:
http://processing.org/
And John Maeda of course:
http://www.amazon.com/Design-Numbers-John-Maeda/dp/0262632446/ref=sr_1_5?ie=UTF8&qid=1331043844&sr=8-5

Finally, incentivising a child's behavior is not that difficult. Make them do their homework before they play. Make them program before they do their homework. Reward them for everything you make them do. Being a smart parent is the best ingredient for a child's intelligence by a mile.

http://processing.org/

It's been ported to nearly every language, does 2d and 3d, has a straightforward syntax and lots of math libraries, physics engines, etc etc.

Im sort of in the same boat (Graphic Designer with aspirations to be a UI/UX designer) and am learning to code of my own accord. I've had much success with Processing. It's really easy to get started and get functional code running. Also, you can run your processing files on a webpage with Java or Processing.js. I don't know about the large data sets you're dealing with, but since Processing is java based, I assume there won't be much difficulty

I did the same thing for a group of middle school students back in 2005 and after evaluating a bunch of graphics and sound libraries, we settled on Basic4GL.

Basic4GL is everything BASIC was, except without line numbers and with all the GLUT functionality built in (minus the initialization cruft). It also supports sound, loading a bunch of texture formats, and has the NEHE tutorials ported to it, and runs on VERY low end hardware. Download and run the demos -- you'll be impressed.

The kids did exceptionally well. We got a classroom full of (failing) middle school students to understand the idea of a coordinate system, and use this to design their own spaceship (using only a piece of graph paper and their own derived x,y coordinate pairs). We then guided them through animating this spaceship with key press events (and in the process they learned about coordinate transformations).

Our goal of having them design their own textures and sound effects never quite panned out, since we ran out of time -- but our ultimate goal was a classroom produced game where every student had a piece of the production workflow.

Afterwards, I found myself using Basic4GL for OpenGL prototyping since it does away with so much of the initialization, etc.

For example, the following is a whole Basic4GL program to draw a triangle

glBegin(GL_TRIANGLES)
        glVertex3f(0, 10, -30)
        glVertex3f(8, -4, -30)
        glVertex3f(-8, -4, -30)
        glEnd()
SwapBuffers()

This was, of course, several years ago. You may find something better now (I'd recommend looking into Processing. I'd stay away from anything that a kid can't set up on his own (i.e., combination of multiple libraries)).

For the classes, you want to emphasize the basics while at the same time giving them something they can sink their teeth into from Day 1. I started with having them type in a very simple program in the first class and then run it themselves. I went from there to what the coordinates mean, etc. You will find that some kids are faster than others, and some of them might surprise you. You will also find that they'll do really well teaching each other.

Good luck!

Processing can be a lot of fun for small projects: http://processing.org/discourse/yabb2/YaBB.pl?num=1222641158 Pros: Cross platform, java based, simple IDE, supports keyboard/mouse input, 2D/3D. Cons: Only downside is limited audio support.

Do some "creative coding" with p5 in Java ( http://processing.org/ ) or OpenFrameworks in C/C++ ( http://www.openframeworks.cc/ ).

Make some art, it's rewarding.

Find an open-source project that you like (Focus on the community) and have some fun solving problems that look fun to you, and add new features.

Do some "creative coding" with p5 in Java ( http://processing.org/ ) or OpenFrameworks in C/C++ ( http://www.openframeworks.cc/ ).

Make some art, it's rewarding.

I have used these open-source hardware boards for quite some time in a university setting.
littlebirdelectronics.com/collections/arduino

They are USB and programmed with the wiring and/or processing software (open-source, multi-platform).
wiring.org.co/download processing.org

They are cheap, robust and easy to program.

You know, I first got started programming when I happened upon a left hand basic cartridge with an Atari 400 for $5 at a garage sale. It came with an attachable floppy disk drive that was DOA. Countless hours would be spent with a small black and white TV with me writing procedures. Should the power turn off, all that work was lost.

Despite growing up below the poverty line working on farms, I was able to go to college with enough grants based on need. This is where our paths diverge ... and I would not automatically assume that my four year degree at the University of Minnesota would make me a better programmer than yourself or anyone who taught themselves to code. But the important point of this is that when I interview (and I've held interviews for programmers to come onto my team many times) the interviewer is looking for you to prove that you will be a self motivated asset to the team. If you can put MIT or some prestigious school, they often lower their required threshold of proof. If you put U of MN there is still proof required -- after all there are some ~50k students at the U of MN and as such it would be entirely possible for some idiot to be herded through with the other cattle. So they just need to make sure I am not this idiot -- or at least not in the area they need me for. Now, when you have institution to back up your claim of skills, the proof requirement quickly becomes insurmountable.

So I will issue you a challenge and I will target the Ruby language and Rails framework. This probably isn't the best option for a job seeker (I think some Java with maybe Spring Framework would be better suited for a position) but this could result in proof. If you want reading material for any of these steps, I recommend the Pragmatic Programmer series on Ruby and Ruby on Rails (used it is quite cheap but here is a free alternative).

Step One: Learn Ruby. Ruby is a functional language that is very simple and easy to learn but difficult to completely master. The flexibility of the language seems to continually leave me with more and more options at my disposal. From mixins to domain specific languages, it just keeps on giving. I'm guessing with your background you're going to notice that some things in Ruby are slow. This is okay. As computers have gotten beefier, programmers have sacrificed performance and (to a large degree) memory in order to make code easier to maintain and write.

Step Two: Learn Rails. Rails is a very extensive framework that is again easy to learn. That tutorial should show you how to master concepts like quickly creating a CRUD (Create, Read, Update, Delete) application for a blog or recipes (I forget). From here you have to use your imagination. Make something that is CRUD or some mutation of CRUD to demonstrate that you know how to utilize and extend this concept. You might use census data and experiment with new UI toys like Processing or HTML5's Canvas element. I think if you have access to some mildly interesting data that building a site you'd like to share would be a great idea (even if it is just in CRUD format). But get it to a state where you're proud of it.

Step Three: Github. Put your source on Github.

Step Four: Host your project on Heroku. You might buy a domain name if you're open to $12/year. I don't know how far you want to take this part. But get it so that people can access it.

Now once you've iterated over that a bunch

Proce55ing (JVM front-end, so it runs anywhere, easy, clean, concise, designed for beginners but still powerful lots of graphics capabilities, Arduino microcontroller programming is based on it)

Frink (the ultimate desktop calculator - JVM-based, runs on anything including phones, 1-click install or web interface, terminal or text-editor interface, can write self-modifying code (eval, 1st-class functions), allows converting nearly any combination of physical units that has ever been used, has obsessively exact date/time arithmetic, number theory functions, default rational arithmetic, arbitrary precision arithmetic, symbolic computation, interval arithmetic, physically dimensioned graphics, animation, natural language translation, currency and inflation-adjusted monetary conversions, Java introspection and embeddability in Java programs ...

And it's really easy to use, for example, type at the command line:
        teaspoon water c^2 -> gallons gasoline
it returns:
        3164209.862836101
Which is the mass-energy equivalent of a teaspoon of water expressed as US gallons of gasoline.

My immeadiate reaction to this article was Python. However there is a fun language out there that gives a lot of bang for your typing called "Processing" it's targeted at artists and rank amateurs. It won't get you a cool prgramming job, (maybe I'm wrong), but it will get you programming with a small language and easy to learn libraries. Lots of examples are included in the compiler download. http://processing.org/ [processing.org]

http://processing.org/ it's easy and gives immediate gratification.

Maybe Processing has them scared as shit. Not only does it do OpenGL acceleration in a browser, but it's also open source and nearly a drop-in replacement for Flash or Silverlight.

Hey now, Processing is awesome.

I'd suggest Processing. It's great for putting apps together quickly, has all the basic 2D tools you'll need, plus support for fancy-pants 3D stuff if you want it later. Great community and docs, too. Works on Windows, Linux and Mac.

http://www.processing.org/

It might be an interesting time to explore algorithmic art. There are many authoring environments such as Processing which have a rich array of methods to create using algorithmic techniques. Your friend could perhaps learn a chording keyboard with the other hand, or simply use a QWERTY keyboard one handed to work in such an authoring environment.

This may or may not be his thing, depending on what kind of a person he is, but try to get him into graphics coding. Introduce him to Processing for example, or one of the many similar projects. (It's certainly no replacement for someone who wants to do "hands on" art, but it's a suggestion that fits your requirement of enabling graphic arts without requiring input precision.)

Well, here's my take on it.

I made a visualization of ant pixel bots wandering around a map and laying down virtual pheromone trails as an art project. The results are pretty psychedelic :)

Java applet written in Processing years ago:

http://object404.com/lab/bloodlines

Interestingly, I was able to reproduce the conditions that made ants wander in weird circular loop swarms in Brazil :D

But if you must try, start with something simple and solve a particular problem. Don't listen to people who espouse one language versus another. They are idiots and will never be helpful. You might try http://www.processing.org./ It is a well defined environment with a simple editor and tools and will let you do some really fun and interesting things. A lot of artist use it for various projects.

It's like the old saw about asking a Christian, "Is it okay to smoke while praying?" versus "Is it okay to pray while smoking?"

Of course competent programmers should handle C and all that. The point is, however, that the new ground to be discovered will be done by having non-programmers be able to quickly, easily, and accurately practice their craft with the aid of numerical analysis and data processing. It's the difference between doing something in an afternoon and needing to incorporate a company; pitch ideas; apply for grants/labs; &c.

The cynical programmer will say that the easy languages will inevitably allow fuckups. Well, that's true I guess (although isn't it an interesting project to reduce these?), but in any real project there are already several categories of fuckups (often methodological/statistical) which the programmer is, usually, blissfully unaware of, and will screw the data/results on a much grander and more subtle scale.

Here is a great example of an "empowering" language: http://processing.org/ Yeah, a `true programmer' may call it inefficient, but if it allows someone to do what they previously could not even conceive of, isn't this an infinite gain in efficiency?

I know I am replying to my own thread here but I submitted it without the proecessing links! ... you want to give the kid something easy for a beginner that gives him visual feedback and isn't "plumbing" like C++.

http://www.processing.org/

http://www.amazon.com/Learning-Processing-Beginners-Programming-Interaction/dp/0123736021/

C++ is a good first language to learn but ONLY after the person discovers whether or not they like programming or not. A book I highly recommend is C++ Primer plus, because it starts from simple examples and explains why things are the way they are and gives you an idea of all the work that goes into "coding" a computer.

http://www.amazon.com/Primer-Plus-5th-Stephen-Prata/dp/0672326973

When I was in grade school, there was Turtle, then I went to basic playing with drawing graphic lines and printing to screen. It all gave you a nice direct feel for what could be done. A nice place to start now might be Processing http://processing.org/

Speaking as a self-confessed 'psuedo-programmer artist type', I can say that those tools definitely are available in the form of Processing.

Java really only has tools for programmers, not psuedo-programmer artist types who typically create cool things in Flash.

It seem you've never heard of Processing. It adds a layer over Java with a few simple abstractions over images, sounds, shapes, etc ... This allows artists (who are not programmers, but it's perfectly fine) to make computer graphics art relatively easily. Can be handy also for "real" programmers who want to sketch something graphic quickly.

Now tools for things like this are where Flash beats Java.

Well, there is http://processing.org/

By "interesting things", we'll assume you mean interesting to him.

Given his age, that probably means something webish, so Javascript is the obvious choice for the kind of instant gratification a 12-year-old will need.

If he's into games, then the language of choice is probably whatever will let him mod his favourite.

If he likes to play with numbers, it's VBA and Excel--or R.

Is he into computer graphics (not digital painting)? Then you want to introduce him to Processing.

Lots of choices

Processing 1.0 fill your needs?

You can get some pretty cool projects going quickly and easily with an Arduino. Combine that with Processing and you can do almost anything...

Did anyone suggest Processing yet? http://processing.org/ Java-based, but much easier to get into (has its own editor) - and the site above includes loads of physics / trig etc examples. A great combination for learning programming, maths and physics.

Yeah, it's not even that hard. As mentioned in TFA, they use Processing.js, which is a javascript port of Processing

With the ADD world we live in, the investment needed to see results in a 3D graphics world is going to be a hard sell.

Couldn't agree more. Much as the Real Programmer in all of us wants everyone to start with a course in computer architecture followed by data structures, something more immediate and gratifying has a much better chance of holding a first-time programmer's interest. Hello World in 3D with laser effects. Buffer overruns and lambda functions can come later.

I'm surprised that nobody has mentioned Processing yet. It's specifically written as a "beginner's language" as well as a rapid-prototyping language (immediate gratification) for everyone else. Under the hood it's Java, with most of the annoying crap (public static void...) hidden away from non-advanced users, and library functions to handle most of the common gratifications (drawing attractive 2d/3d graphics, openGL, reading/writing to Web pages / sockets, grabbing data from Webcams, serial port, etc.)

What I like is that it comes with an exhaustive set of examples, those who learn best from example will pick things up quickly. Plus, once the kids have a program they are proud of, they can export it as a Java applet and blog it, it'll run for their friends right in their browser windows.

I got into computers because I could hack the BASIC games on an Apple ][+

Accessibility is king! But finding which thread to grab amidst the jumble of a modern GUI OS is tricky!!

I have just started playing with "Processing" and it seems to have a nice mix of understandable code and super powerful libraries to take advantage of: cross platform, modern hardware and complex meta-behaviours that we might expect.

As well, I am "sandboxing" with "Parallels" on top of OSX and I have found it to be very stable. (It allows virtualization of Windows flavours, OS X & varieties of linuxen concurrently) The images can be booted Read Only or not. Creating a bulletproof, clean starting environment is what kids(and productions) need, and virtualization images might be part of this.

I'm new to virtualization, but it feels like the future to me. Since I have taught in hands-on Lab settings I think this is a better solution for a shared use lab than straight up disk imaging... It would allow week by week, class by class customization of the Boot Image, and changes could always be rolled back.

The fundamental issue with the new RIA standards is the lack the of authoring tools. I have got a number of graphically-inclined friends who are never going to write something with HTML5 mainly because there are no tools out there (yet) which come even close what the Adobe authoring tools can do.

Recently, I sat with one of my friends (who's a decent artist) and played around with Processing 1.0. After several minutes of hard work, it just became abundantly clear that visual thinkers have a lot of trouble expressing what they want algorithmically. The experience was repeated the next time, when he was playing around with chucK (yeah, he's a music dude too).

The graphic artist folks will have a lot of trouble using the HTML 5 authoring tools currently available, especially if they're confined to use HTML Canvas programmatically. I've easily gotten upto speed with canvas, but I'm a programmer with no artistic pretensions.

Real adoption of HTML5 - canvas and video & all, will need easy ways to author media ... not write code.

Ben Fry's Visualizing Data using the Processing environment seems like it's addressing a similar topic... wonder if Vaingast didn't know about it or if he found something unsuitable about it...

http://processing.org/

Clean, quick, cross-platform, can do pretty wild things right out of the box.

Make it fun, get them hooked.

Have a look at Processing, and the book Visualising Data by Ben Fry.

Have a look at Processing, and the book Visualising Data by Ben Fry.

I second that. If you are visualizing graphs be sure to get the igraph package which can be used with R, Python, C, or Ruby.
http://cneurocvs.rmki.kfki.hu/igraph/
Processing is another package that is geared towards data visualization which java developers might find easier use
http://www.processing.org/

I've been teaching middle school kids programming for four years. I don't think the language is that important. What's important is to find good problems that they can work on. And by good I mean: (1) Students find them interesting, (2) early problems are easy so everyone can get a small victory under their belt, (3) the problems scale up so everyone has something that challenges them. The way I teach is I start everyone out on Scratch ( scratch.mit.edu ). Scratch uses drag-and-drop programming which lets you skip all the worries about syntax and jump immediately to logic, problem solving, etc. I.e. the interesting stuff. Most of the students will continue to find Scratch interesting and challenging for a long time (6-months to a year). Your top kids will get bored and then I'd move onto something like Processing ( http://processing.org/ ) or Python with some graphics library such as my MakeBot ( http://stratolab.com/misc/makebot/ ). If people are interested, I can post my Scratch worksheets.