TL;DR: “Little Ruby Codes” is an introductory online course work, but taught in personal workshops, exposing people to programming, software ideas and environments, and the ruby lang in particular, using ideas in literature as a connecting foundation. Through building it, I would gain a mastery in Ruby, encourage/empower new users to take on tech/software, and gain credibility as a developer, educator and speaker. All work would exist on a website using a new TLD, called http://littleruby.codes/
This is the first draft and probably needs twice as much information and then better formatting.
As stated above there are number of real world problems this project would attempt solve.
Software advocacy: The division between people who work with or understand technology and those who don’t understand it is disconcerting, especially as we move forward into this century. This is especially concerning in female, minority and low socioeconomic populations.
One of the issues, in my opinion, is the way tech and ‘nerds’ are branded as an exclusive group. Tech is difficult, by I contend somewhat because of the initial strangeness and language. However, the abstract ideas of algorithms and puzzle solving are pretty universal, and society at large would benefit from teaching more of these critical thinking skills to more of the population, not just in software.
When I was in undergrad, I was interested (as I am now) in evangelizing tech. It was interesting to me that my CS department was only interested in poaching students from ‘like’ majors: physics, IT, and other ‘hard sciences’. As if those had the only possible candidates.
I would like to take a new angle, targeting perhaps those the ‘farthest away’ from the computing sphere, people in literature. Nearly everyone has a relationship with literature and stories on some level, consuming or creating it, and are familiar with it’s mechanisms. Those who create it are especially gifted at handling abstract thought; the ability to conceive characters, arcs and story development is a difficult process. It takes an abstract and imaginative mind to tackle it, the kind of minds I would be after.
Thus, the foundation of this education project would be story telling: converting well know stories into Object Orientated code, while exploring foundational CS concepts (I cover this idea in a bit more detail here)
Software as stories: The main theme of the site would be converting the tale of “Little Red Riding Hood” into a simple ruby project that displays the story on screen, through html files but preferably the console. The name of the site “Little Ruby Codes” is a play on this story, “Red Riding Hood” would simply be changed to “Ruby”. (The focus is on Ruby only. Rails may enter the picture later, but the focus is on translating abstract concepts into code, not building a web app.)
Already, I think this makes it much more approachable. It’s a young female lead in a familiar story. The scope of the idea is small and non-threatening: print a story on screen. And much focus would be on the fact that “Little Ruby” decides/codes her own fate. She may get eaten by the wolf in the first iteration, in some ancient and bizarre cautionary tale of sexual impropriety. But as the course develops, the students can write literally any ending. Maybe Little Ruby flees, or defends herself by growing rocket hands, or befriends the wolf who is only a misunderstood member of the underclass. Focus will be on empowerment and endless creation; students can create literally anything.
From the mechanical side of things, the flow of the early coursework would be an evolution of procedural code to OOP. The first lesson will be a single file, with a series of `puts` that dump the text onto the console. Next we will add variables, then control structures, then objects. The lesson will be that procedural is like ‘narration’, anything can happen but there is no ‘interaction’. The characters don’t decide what happens, they are explicitly told what to do. As the course progresses into OOP, the characters objects will be given methods to decide what to do in a given situation, given a set of environment conditions. IE, littleruby.knocks( door, “Is anyone there?” ) sort of thing. Decisions are made through message passing and the story is dumped on the console.
The really cool part is once the basics are covered, we can get into some advanced algorithm and problem solving ideas, but using the characters and story as backdrop. For example, the fairy tale already discusses the concept of ‘shortest path’, in that the wolf beats Little Ruby to her grandmothers house, by taking the ’shortest path’ through the woods. What if there was a piece of the curriculum, where the wolf actually had to solve for the ‘shortest path’, and the developer had to implement it in code?
And actually, the title “Little Ruby Codes” is a double entendre. It’s first main meaning is “the main character creates software”. The second meaning can be more, ahem “emansive”, to mean “small snippets of ruby code”. http://littleruby.codes/ can tackle and discuss items like http://rubyquiz.com/ or other similar sites.
Tackling the hardest parts first: This of course won’t be the first education ruby site on the web, http://tryruby.org and http://codecademy.com are great examples. These sites are great at exposing people to software ideas, but I’m not sure they are great at empowerment. So much about development is the tools and environment. At the end of the day, when the student completes these site lessons, I’m not sure they are any better at programming on their own. Without the security of the in-browser IDE, they aren’t empowered to create and explore on their own; they simply aren’t equipped.
There is so much confusion on version control, IDEs, servers and deployment, I
definitely skeptically want to tackle this first. Getting the student on a consistent environment with explicate instructions on getting a vagrant instance running, installing rbenv and pry and a git gui, I believe will pay dividends for them in the future. I prefer they get in the habit of committing code and executing from the command line, from the very start. This way all instructions are built on a consistent environment (can expect the exact same scenarios) and the user is encouraged, equipped and empowered to try new things from the very beginning. And if we provide them the scripts for installation, it should be relatively simple (fingers crossed).
The learning curve on this piece might be too steep as the introduction, so I am a little hesitant. I believe though that the course should have a workshop atmosphere, and every user should have their own machine where they can break and fix their own code. With a heavy amount of teacher handholding in the beginning, there would be less later on. The students would be encouraged to ask any and all questions, but equipped and encouraged to explore solution on their own. You know, troubleshooting.
Presentation: As stated, everything would be on a website http://littleruby.codes/ where all instruction would be written to help get the user up and running on their own mac or windows machine (and possibly linux). Curriculum would be broken up into ‘books’ and ‘chapters’ and http://littleruby.codes/book-0/chapter-0 would be an instruction for executing a ‘Hello, World’ on their own newly installed ubuntu vm (or which ever is best).
All code and instructions would be open source. In fact, the site tutorials would be built in a way, that a little js would convert them to “slides.” The idea would be hopefully over time other people around the world would be empowered to teach the same curriculum, and can just use the ‘slides’ available on the site. (I’ve experimented with this idea already when I presented at the last Cville WP meetup. The ’toggle notes’ button converts the tutorial to presentation mode, and this concept will mature over time)
- Print to console
- Control structures and logic
- Version control
- Text editors
- Bash execution
- Vagrant and VMs
- Pry and Ruby Console
- Hashes and Arrays
- Much, much more
Algorithms and Problems:
- Trees and graphs
- Quickest path