You're coding and you finish a small but useful program... which turns out to be VERY useful. Which leads you to expand and improve its functionality over time. And as you continue to expand that code... you unexpectedly arrive in a place where it's difficult to work on it. You can't figure out why new bugs are popping up in code that used to work. It's difficult to think about how to add a new feature to the program -- so you carve out a new space and hastily wire it up into the old code! Now THAT rats nest of digital wires starts to haunt the code whenever you have to update it. Spaghetti.

And I'm here to tell you to eat that spaghetti. It's delicious.

Mount Spaghetti, a destination every programmer is well familiar with and which all of us must visit on our career journey! It's an unsightly place, but one that inexperienced developers really can't avoid. But it's also a base camp of sorts for skill development.

And which skills? Code refactoring, which requires the ability recognize, extract and apply coding patterns.

So yeah, eat your spaghetti because it'll help you learn valuable programming techniques that you'll need to avoid it in the future. To start, focus on solving the problems in your code and head over to YouTube to see a brief demonstration of the following steps.

First, identify the data in your program and separate it into 2 categories: inputs and outputs. This can help you identify useful data structures, which will be important to organizing your data. Further, distinguish the configuration data from runtime data.

Step 2: Visualize
Next, create a visual diagram or drawing of the program flow. If you’ve never done this before, it can feel a bit slippery. But frankly, if you’re not in the habit of visualizing the problem, it’s one reason you have spaghetti code in the first place. I tell my apprentices all the time: if you can’t explain your program in your first language (e.g.: English) or draw me a picture of what it does, then you don’t understand the program. 

It’s impossible to overstate the importance of this step – to untangle something is to understand where it begins and where it ends. You’re trying to identify structures, behaviors and data in order to place them strategically.

Think of this as kinda like making a map. It marks places, important landmarks, and displays topological information. A good map may even tell you why you want to visit certain places. It allows the user to create paths to where they want to go -- and to avoid all the places they don’t want to go.

Step 3: Implementation
Ideally, you started down this path with a working program. Your goal is to ensure it continues to work as you refactor it. This means going in with a scalpel, not a chainsaw. You can add new code, but you don't want to remove the old code until the new code works -- or you'd better have a damn good reason to do otherwise.

Name the different states, processes and behaviors you’ve identified. With your whiteboard nearby, head back to your keyboard, turn on the debugger and gradually implement the plan 1 line of code at a time. Revisit the whiteboard as you learn new things during implementation, clarifying your map and refining your process. This step may take a while. But see it through -- do it until its done.

Describing the process like this in a video or article is kind of a challenge in itself, because programming isn't really a neat and tidy process. It's quite messy and things never quite go the way you want. So you're constantly experimenting, learning and applying new ideas, adjusting your plan as you go. There's a lot of back and forth: you design a system on a whiteboard, try to build it then head back to the board after learning where your ideas fall short. 

However, in the end there should be a lot less spaghetti on your plate when you’re done. Your program should still work and you should find it less intimidating to revisit for updates and new features. Refactoring is always worth the effort and the trick going forward is to do it a little more often. Programming is an iterative process and truthfully, you can iterate as long as you want. So it's important to set boundaries -- a topic for another day.

Consider that the era between roughly 1975-2000 was a time where many of the most revered and celebrated software developers of today started their careers by teaching themselves to code. Wealthy companies hired these enthusiastic young programmers on nothing more than the word of a colleague. In the earliest days of the profession, everyone was self-taught and learned the details on-the-job.  These people made very, VERY good money and today they're set for life. Learning to code lead straight to a high paying, stable career.

So ...then what was Learn to Code movement about?
This informal movement started about the late 2000s, right as smartphones took over the world and before Kanye West became Yeezus. This movement wasn't just a reflection of the voracious industry appetite for software developers at the time.

More importantly, it signified that people were no longer teaching themselves computer programming -- or at least not nearly enough of them. I think the popularity of the web changed how people used computers entirely, centering the experience on the browser and thus narrowing how we interact with the machine in a major way. Long story long, the industry required a whole movement to encourage more people to teach themselves programming -- so they could hire them.

Consider the implications here, because it tells us some important things:

The Learn to Code movement was well-intentioned, and it encouraged people to explore their unique interests in digital technology. For generations such as millenials, the web was highly accessible, inviting users to learn web programming over traditional programming (for lack of a better term). Back then, I could expect my non-technical friends to have some knowledge of Javascript simply because they operated an active MySpace page!

Many a hobbyist/hacker became web developers by simply chasing their interests in their corner of the web. There were 2 big promises made in this era:

It worked. Post-2008 crash, many people were desperately seeking a well-paying career with maximum flexibility. And computer usage continued to increase dramatically ...for many of us, but not all of us.

Those Left Behind
Now as accessible as all this programming knowledge was, keep in mind that you still needed a decent computer to pursue any of this. Low income households were more likely to have an Xbox than a PC. It doesn't matter how many free tools, tutorials, and resources there are on the web if you don't have broadband at home. And that often also meant you weren't adjacent to any people who had a computer or used them regularly, meaning fewer opportunities to even learn about them.

So while the Learn to Code movement was in full swing, there were still entire swathes of the country who did not have access to this career boom. By the time poorer communities caught up, the movement had largely petered out, and web development roles were becoming saturated while traditional computer programming was still having trouble filling entry level roles.

Suddenly self-taught programmers were sus' to the very same organizations who put out the call to learn to code. And here we are.

Learn to Code is less a cautionary tale than a reminder that software development has always been lead by self-taught programmers. The best of us augmented our educations with the technical skills, which bolstered that success and lead to a stable career. Running a tech training program for Apprentices provides much needed structure and mentoring to accelerate skill acquisition and add depth of knowledge.

The Point
Paying thousands of dollars for someone to educate you about computer science has never been a prerequisite to becoming a skilled software developer. Waiting 2-4 years before someone will consider you for an entry level role is a terrible proposition. The Guild believes that apprentice training is an approach best aligned with building a stable career path for aspiring software developers. 

So we still haven't come up with the exact perfect title for our project -- at last year's announcement we've been going with T3 Matchine! The project we're working on hasn't changed, but the working title has: The Oak (the Cookout).  Last year we started with a match 3 game. It's a favorite genre of mine (Lo) and it was accessible for junior programmers. 

This year we're working on the card game: Spades. And so far, this is easily our favorite part of the game. It's actually transforming our approach to the project in really cool ways that we can't wait to showcase. As full-time training winds down this month, it's time to transition back into project mode.

The Apprentice Training Program is intense, as any candidate will tell you. But during that time, the Guild puts our projects on pause to focus our attention on our apprentices. The goal is for them to be ready for work -- and in this case, ready to join this project and contribute!

We'll be making all development updates here, but if you really want to get into the juicy details of how the project is made, you should follow us over on Itch.io. We're super excited to get back to this project and we think you're going to like it too!

Last year we did a coding series, Overbyte, for software developers looking to improve their skills and knowledge with Python, and it was very well-received! During workshops, we'd pick a small project, build a prototype and then repeatedly iterate on it using very unnecessary and advanced programming techniques.

Why do this, I hear you ask?

To have fun with our craft, of course ...and to LEARN! Overbyte is about seeing the development process as iterative, watching the code get better and better with each improvement, and honing your craft. We use this workshop to share ideas and to learn to be better builders of software. 

Python Software Foundation is a sponsor for this workshop series, and we thank them for their support. Without sponsors like PSF, we wouldn't be able to offer free, professional workshops to our community! 

The first events are in-person, but we'll continue doing the online versions of this workshop as well. Come downtown for a session, meet some cool people and learn how to become a better software developer! 

We're on a mission to demonstrate to our community that small contributions make a BIG impact. We can deliver tech programs every season off the contributions of the first 500 supporters. While it doesn't stop there we see it as a symbolic and impactful message: 

We develop FREE tech training programs in Oakland and neighboring Bay Area communities. Contributions stay in our city by design -- we want to use technology to build and improve the lives of the people HERE! Each contribution makes it possible for us to deliver monthly training programs at no cost to participants:

We work with other local organizations to bring you these programs every month. This year alone we've been working with Rubicon CORE, Oakland Public Library, and Job Resource Center. Our work has been supported by sponsors like Python Software Foundation and Oakstop, as well as individuals who prefer to show their support anonymously. 

How can you contribute? You can become a regular supporter by becoming an official Guild Supporter on Patreon or Paypal. Or you can give individual contributions any time you like through the following channels:

 As a non-profit, all contributions are tax free, extending the power of our village even more! Patrons can receive swag, including our dope logo on a shirt, Smooth Operators game, and early access to our first digital project! Contributions larger than $100 should visit the workshop or contact us to receive a special invitation to our next event!  THANK YOU FOR YOUR SUPPORT. We literally cannot do this without the support of our community and we wouldn't have it any other way. 

We're here to serve!

We're partnering with West Oakland Public Library for Teen Tech Lab this Summer in June! For those aged 12+, we're creating a dynamic workshop where youth can explore the digital alchemy of coding! This event is free to the general public. 

Participants will learn how to build the most popular software ever: video games! And this isn't just coding, as we'll create 2D/3D art and digital music, all while learning how to combine them into an interactive gaming experience with code. 

You can register to participate by: 

Space is limited and participation is on a first come first serve basis so don't wait!