DEV Community: Jeremy Grifski

Sample Programs Repo Celebrates 1,000 Code Snippets

Jeremy Grifski — Fri, 10 Jan 2025 16:29:09 +0000

It’s 2025, and we’re kicking off the year with some huge news! The Sample Programs repo has hit 1,000 code snippets. Let’s talk about them.

A Brief History of the Repo
1,000 Program Breakdown
Looking Ahead

A Brief History of the Repo

I maintain a repo called Sample Programs that first started as a 100 Days of Code challenge in 2018. Back then, I challenged myself to write a Hello World program in as many programming languages as possible, and I even turned it into a series on this site.

Over the years, the repo has evolved dramatically. For instance, one of the earliest changes was the addition of different types of programs. If I recall correctly, I added “reverse string” and then “game of life,” the latter of which is no longer a part of the repo.

Around the same time, I started advertising the repo on dev.to to see if I could get any contributors. In the early stages, it was pretty easy to contribute because many of the popular languages, like JavaScript and C, needed contributors.

Then, I discovered Hacktoberfest, which quickly became my main way of getting help on the repo. By creating issues targeting specific holes in the repo, folks were quick to jump on them. It wasn’t long before I started to get some repeat contributors.

Eventually, the repo got popular enough that folks began helping expand it in new and interesting ways. For example, we put together a documentation site that would show off all the programs in the repo and even support documentation for them where needed. Likewise, some folks were interested in ensuring that all the programs of a particular type behaved identically. As a result, glotter was created to help us test all the programs.

Since the beginning, a lot has changed about the repo. As of today, there are 37 different types of programs (which we call projects) that can be implemented in the repo, all of which are automatically tested. That’s quite the change from the original “Hello World in Every Language” challenge. In addition, the repo has amassed 154 programming languages, of which 153 are tested.

On top of all that, the repo supports a ton of automation. For instance, testing has since been upgraded to glotter2. In addition, all of the languages have READMEs, which are generated automatically to provide readers with information about which programs are still needed. I’m sure there is even more that is slipping my mind at this point.

Perhaps most interestingly of all, the repo just hit 1,000 programs after about 7 years of work! In the remainder of this article, we’ll talk about that huge milestone.

1,000 Program Breakdown

When you consider the Sample Programs repo, it’s an interesting case study into which languages are popular and which languages have sort of a cult following. I say this because many of the popular languages are complete (i.e., have a program for all 37 projects) or nearly complete, yet there are some more obscure languages in a similar boat. I’ll show you what I mean.

Here are some languages you would expect to have contributors, at least based on GitHub’s most recent annual report of the top programming languages:

C (26 code snippets)
C# (29 code snippets)
C++ (27 code snippets)
Go (29 code snippets)
Java (26 code snippets)
JavaScript (30 code snippets)
PHP (37 code snippets)
Python (37 code snippets)
TypeScript (23 code snippets)

Yet, there are plenty of languages that don’t crack the top 10 that are clearly beloved by some (or at least interesting enough to be worthy of contributions):

ALGOL68 (37 code snippets)
Beef (37 code snippets)
Commodore Basic (37 code snippets)
Euphoria (37 code snippets)
Haskell (20 code snippets)
Julia (14 code snippets)
Kotlin (19 code snippets)
Lua (13 code snippets)
Mathematica (26 code snippets)
Octave (14 code snippets)
Perl (18 code snippets)
R (10 code snippets)
Rust (37 code snippets)
Scala (11 code snippets)

And yet, there are still some popular languages that lack contributions:

Objective-C (11 code snippets)
Ruby (17 code snippets)

In addition, GitHub keeps track of the most used languages in a repo, which I assume is based on lines of code. In our case, the top languages come out to be:

BASIC: 11.7%
Beef: 9.6%
Rust: 7.0%
PHP: 6.7%
Mathematic: 5.0%
Python: 3.7%
Other: 55.3%

There are other statistics I could probably dig up, like most popular project to implement, but I don’t quite have those on hand. Maybe I’ll make something more thorough when we hit 2,000 code snippets.

Looking Ahead

It’s really cool to me to think that a repo I put together to challenge myself has become something much larger than myself. These days, I really don’t do a ton to maintain the repo. Instead, there are a ton of wonderful folks that have primarily maintained the repo in my place over the years. These folks include but are not limited to the following:

If you’d like to see this repo continue to grow, I’d encourage you to jump in the Discord to see what ways you can help out. It’s been some time since I’ve cross-posted to dev.to, but I have that platform to thank for where the repo is today. As a result, if you’re reading this post over there, thank you for continuing to build a positive tech community.

With that said, I’m going to wrap this one up. As always, if you liked this article, there are surely several more where that came frome:

Likewise, you can help support The Renegade Coder by checking my list of ways to grow the site. Over there, you will find links to the Discord, Patreon, and Newsletter. Otherwise, take care and thanks again for all the support!

Support The Sample Programs Repo This Hacktoberfest

Jeremy Grifski — Fri, 08 Oct 2021 15:24:41 +0000

As of today, we’re a week into hacktoberfest, and I’m wondering: how is it going for you? Have you completed your four pull requests yet? If not, may I interest you in a project that is open to pull requests from anyone who has programming experience. Don’t believe me? Keep reading!

What Is the Sample Programs Repository?

In early 2018, I was in the middle of a transition between industry and academy, and I was looking for a way to take advantage of the free time. Back then, I was interested in learning programming languages, so I decided to leverage 100 days of code to write one hello world program in a new language every day.

During that journey, I started writing articles to describe the programs I had written. It was a great way to get exposure to various programming languages, so I kept doing it for awhile.

Of course, after several dozen languages, I decided I had enough of surveying the landscape. As a result, I figured it was time to expand the collection to include other types of programs. For example, the first two programs I added were reverse a string and game of life. Together with hello world, the Sample Programs repository was born.

TheRenegadeCoder / sample-programs

Sample Programs in Every Programming Language

Sample Programs in Every Language

Welcome to the Sample Programs in Every Language repository! What began as a simple 100 Days of Code challenge has expanded into a fun project. Within this repository, you'll find a growing collection of sample programs in just about every programming language to date.

Learn More

To get up to speed quickly, check out the contributing doc. Otherwise here are some helpful links:

Projects: a list of projects currently accepting code snippets
Discord: an invite to our community discord
Code of Conduct: a copy of the Contributor Convenant
License: a copy of the MIT license document
News: a series of articles about what's happening in the repo
Template: a template repo, so you can create your own collection

Support

Sample Programs in Every Language is a project run by myself, Jeremy Grifski, as a part of my website…

View on GitHub

Today, the Sample Programs repository features an overwhelming 162 programming languages and 604 code snippets. Of course, these numbers are always growing, so the collection could feature many more code snippets by the time you read this. Also, remember how I mentioned the collection featured three types of programs? Well, now it features over 40.

In short, the Sample Programs repository is a collection of code snippets in as many programming languages as possible. Why not come share you knowledge with us?

Who Is Eligible to Support the Sample Programs Repository?

At its core, the Sample Programs repository has always been a place for learning. As a result, anyone should able to make a contribution regardless of size of impact.

With that said, things are different from when I set out on this journey in 2018. These days there isn’t a lot of room for folks who are familiar with popular languages such as Python and JavaScript. At the time of writing, Python has code snippets for 30 out of 40 possible projects, and folks are often quick to fill the missing code snippets.

As a result, I think the best way to approach the Sample Programs repository is to use it as a tool for learning a new language. For example, Julia is a relatively new programming language that has a lot of support from its community. However, it lacks support in the Sample Programs community with currently only 7 of the possible 40 code snippets completed.

Another thing that is cool about the Sample Programs repository is that it’s not all code snippets. We also have built-in testing for as many of our code snippets as possible. Unfortunately, this feature was added more recently, so it’s not totally fleshed out. As a result, if you’re interested in working on testing, there’s more information on that in the next section.

Like testing, we also support documentation. For example, if you check out the Python README, you’ll see a list of programs in the repo. Anything marked with a green checkmark has documentation. As a result, if you’re interested in supporting our documentation efforts, there’s more information on that in the next section.

Beyond that, I generally encourage anyone who’s willing to support a project like this long term to check it out. Or at the very least, check out our Discord and get to know some folks who are writing code for the Sample Programs repo.

What Kind of Work Can One Accomplish During Hacktoberfest?

Previously, I talked a bit about the major facets of the Sample Programs repository that folks might find interesting. That said, the vast majority of work that goes into the repo during Hacktoberfest is code snippets. Then, throughout the year, we spend a lot of our time getting ready for the next Hacktoberfest. However, why limit yourself? Here’s a list of the types of things you can help us with this Hacktoberfest:

Contribute code snippets to less popular programming languages (e.g., Julia, Clojure, etc.)
Write tests in Python for currently untested projects (e.g., maximum array rotation, etc.)
Write tests in YML for currently untested languages (e.g., quack, etc.)
Write documentation for the copious amounts of undocumented code snippets (PLEASE)
Develop a prettier Jekyll website for the documentation
Assist in various automation tools for the repository

If any of these things interest you, feel free to reach out. Alternatively, you can head straight over to the Sample Programs repository and read the contributing doc for more specific details.

In general, however, we are going to try to resist new projects as we’re already quite behind on testing and documentation. If you have any ideas for new projects outside of the 40 existing projects, we ask that you write documentation and testing for them before we’ll accept any code snippets. In other words, you’re welcome to contribute to the popular languages as long as you’re willing to define new projects fully.

How Do I Support the Sample Programs Community?

If Hacktoberfest isn’t your thing, but you’d still be interested in helping out the community, there are several ways to do that. First, the Sample Programs repo is maintained by The Renegade Coder organization—or rather myself. In other words, any of the ways you can currently support The Renegade Coder will also support the Sample Programs repository. For example, here are just a few ways you can help out:

Also, if you’re interested in keeping up with what’s going on in the various Sample Programs repositories, I maintain a series about exactly that. Check it out to learn more about the history of the project.

Likewise, I’m not the only one who continues to maintain this repository. As always, there are many, many folks that deserve thanks. However, none deserve more thanks than @auroq who was responsible for getting the testing off the ground for the Sample Programs repo. Feel free to give them a shoutout!

While I’m here, I should mention that I recently made a template repo, so folks could make their own Sample Programs repo. Maybe this Hacktoberfest, forget the Sample Programs repo. Make your own! I’d love to see how folks make use of that template.

With that said, that’s all I have to say about this year’s Hacktoberfest. If it’s your first time, I hope you get a chance to find a community that supports you.

How to Get Better at Programming: Lessons from Blogging

Jeremy Grifski — Mon, 21 Jun 2021 02:32:08 +0000

Look, I can’t help but write articles in this series. Very rarely do I get a chance to brag about various skills I’ve picked up in my life, and I’ve had a lot of fun doing it. Today, let me brag a little bit about my blogging skills and how they might be useful in programming.

Blogging Expertise

Blogging was not something I got into until it was already long deemed dead. Whether or not that is true is entirely up to debate, but I didn’t get started until 2016. Back then, I had just graduated with a degree in computer engineering and I was working at a company for the first.

Very early on I realized that I wanted to work for myself, so I decided to get a project in the works with a friend of mine. About six months into that project, we parted ways, and I launched The Renegade Coder. In just a couple of weeks, we’ll hit the 4 year anniversary of that move.

Normally, I wouldn’t consider myself an expert in something like this because I haven’t been doing it very long. Also, I’m self taught. I have no formal writing training, and I’ve just kind of been on that grind for the last couple years.

That said, I have done a lot of writing in four years. As I write this, I have 442 published articles on this site—not to mention another handful in other places. In addition, until this year, I kept a pace of about two posts a week. Lately, I’ve slowed that pace to once a week, but I’m very consistent regardless.

As a result, I think I sit in a relatively experienced realm of expertise, but I still have a lot to learn. Also, because I’m self taught, I think the tips I’ve learned from blogging will help most with folks who are trying to teach themselves programming. Why don’t we dive in?

Lessons From Blogging

To the average person, blogging and coding probably seem like very different fields. However, I think they align in a lot of ways. For example, programming is far more creativity than people like to lead on. In the same breath, blogging is a strategic and logical process. I don’t just write whatever I want; there’s thought that has to go into it. As a result, I think programmers could learn a lot about getting better from blogging. Here are a few of the connections I drew.

Pacing Is the Key To Progress

When it comes to blogging, I think a lot of folks give up pretty early on. For instance, they try to do too much too fast, and they end up burning out. In other words, their pacing is all off. For anyone at this stage, I’d recommend queueing up any posts you have planned on a schedule that you’re comfortable with. For instance, if you write 10 articles in the first week, spread those out over several weeks to save you from burnout.

In addition to saving your own mental health, pacing is very important for a website in general. From a technical standpoint, pacing provides a schedule to various search engine crawlers, so you can guarantee your work is indexed regularly. Practically, pacing provides momentum that allows your site to grow gradually and predictably over time.

I tend to think this idea of pacing can help a lot with your learning in just about any field. That said, because of how taxing programming is on the brain, pacing is especially important. For example, I know a lot of folks recommend doing 100 Days of Code or other similar daily challenges. This can be incredibly tiring over time and eventually burn you out.

Even if you’re really passionate about coding, I’d still recommend setting a comfortable pace for yourself. Don’t try to fill your entire GitHub grid up like a masochist. Your time is best spent finding the balance between resting and learning rather than forcing yourself to get better.

Interest Matters for Long Term Sustainability

Nothing fosters Writers Block more than when you choose uninteresting topics. In the age of search engine optimization, it can be hard to grapple with this reality. After all, content won’t rank unless people are actively searching it up. That said, you’ll never last as a writer if you don’t have interest in your work. Again, you have to strike a balance.

For me, this means regularly pivoting to new topics as they become interesting to me but remaining in my niche the best I can. Hopefully, you see what I mean by this entire series.

Like blogging, programming requires a lot of interest to avoid burnout. Generally, I don’t think people are inherently interested in programming. Typically, they’re more drawn to problem solving, opportunities to help people, and chances to create cool stuff.

As a result, you need to work on projects that interest you. If you’re interested in developing apps, develop apps. If you want to make a video game, make a video game. It can be quite painful early on to work on abstract concepts just because it is the norm. Find the domain that interests you and get right into it. Surely, there are folks like me creating content geared toward beginners in your niche. If not, why not hop on the blogging bandwagon as well?

Creativity Maximizes Outcomes

One of the things I love about blogging is that I can basically use the platform however I’d like. There’s great power in that kind of freedom, so I try to flex it as often as possible. For instance, I’m really enjoying writing this series whether or not it makes it in front of people’s eyes. After all, it’s cool to be able to catalog bits of my life and turn them into helpful tips for others—as well as my future self.

This creativity can lead to a lot of late nights where I jump out of bed to write down a cool idea. Most recently, that idea was this series. That said, I really like my “Roll Your Own Python” series, and I’m sure I’ll come up with another idea that I’ll deem as genius a month from now.

From a programming standpoint, I know creativity can go a long way. In other words, surely you have dreams of things you’d like to try to make, right? Why wait? Programming is an iterative process. Maybe you can get a rough prototype going now and write the whole thing from scratch with your new knowledge later. I know I’ve done this several times. For instance, I tried creating a library app that I could monetize. I never quite got all the way there, but I was able to learn a lot of cool technologies along the way.

I really think programming is modern day magic. If you have an idea, you can probably make it a reality. The key is to start with an idea.

Readability Helps the Reader

Blogging can take many forms. Personally, I tend to use blogging as a form of education. As a result, I want to make my writing as digestible as possible. If people can’t make sense of it, they won’t learn anything. Even worse, they probably won’t return for your help.

There are a lot of ways to work on your readability, such as having folks read your work and give your feedback. That said, a lot can be said about putting in the work by being conscious of your writing. One way you can do that is to consume a lot of other folks’ work. Alternatively, you can do some writing on a rough topic and revisit your own writing later.

The latter technique described above translates almost perfectly to getting better as a programmer (though, they’re both helpful). Trust me. Take a look at the first bit of code you’ve ever written. It’s pretty rough, right? I know mine was. Now, think about all the ways that you’ve improved. In what ways can you get even better?

Generally, I find readability to be an important skill in any work you do with others. That said, as I’ve said in the past, you really should be working on readability because it impacts your future self. There’s no doubt in my mind that you’ve ran into code you’ve written at some point and immediately cringed. That should be a quick hint to keep working on your communication skills—they should never take a back seat in your code.

What Else Can Programmers Borrow?

Welp, that’s all I have for today! Honorable mentions include some of the following ideas:

Platform Choice (e.g., WordPress) Should Align With Your Goals
Writing Can Be a Form of Learning (i.e., to teach is to know)
Guest Posting == Open Source Contributions

At any rate, for my programmer friends out there, how did I do? Did you pick up any new ways to practice coding? Are you interested in exploring blogging? Were you surprised by any of the connections I made?

For my blogging friends out there, what did I miss? Are there other lessons that you think can transfer over to programming? Do you do anything like this? How else has blogging helped your programming career?

Once again, thanks for stopping by. If you’d like to support the site, I have a list of ways you can do that. There, you’ll find links to Discord, Patreon, and YouTube. Special thanks to David Hopp, our latest Patron! Otherwise, thanks again, and take care!

What Are Some Tech Questions You're Too Afraid to Ask?

Jeremy Grifski — Wed, 19 May 2021 00:21:02 +0000

I had an idea for a series of articles on concepts that people in tech assume are common knowledge but actually aren't. For me, this would include ideas like "what is Kubernetes?" and "what is a framework?" Hell, I just saw Kyle bravely mention that he had no idea what Vim is:

// Detect dark theme var iframe = document.getElementById('tweet-1394806711127523330-112'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1394806711127523330&theme=dark" }

So, I think it's safe to say any question is on the table. Fire away!

How to Get Better at Programming: Lessons from Competitive Shooter Games

Jeremy Grifski — Tue, 04 May 2021 19:35:30 +0000

Alright, you caught me! I couldn’t help myself. Once I wrote that article about music and its relationship to programming, I wanted to write about all of my hobbies. Today, we’ll talk about one of my favorite hobbies, gaming, but specifically competitive shooters. There’s no doubt I’ll do one of these for one of my other favorite genres: role playing games.

Competitive Shooter Expertise

I was born in ’94, so my relationship with competitive shooters starts with Halo. I played the first three Halo games pretty regularly before moving on to games like Gears of War and Call of Duty. Back then, I was a console kid, so all my shooter experience was with a controller: Xbox, GameCube, or otherwise.

Realistically, I wouldn’t say I was competitive in these games. Sure, I played a lot of ranked. For instance, I remember getting stuck at the border of Colonel and Brigadier in various playlists in Halo 3. I don’t think I was ever quite that good at Halo 2. Likewise, I climbed fairly high in Gears of War in the Wingman playlist with a friend. That said, I never went to any official tournaments for these games. I generally just solo and duo queued in various playlists.

As I got older, I transitioned into PC gaming. For instance, I started to get into Overwatch, which was my first PC shooter, at the time of the beta. These days, I still play Overwatch, but I’ve also begun to dabble in Valorant. And, I even sometimes leverage tools like Aim Lab to get better.

In terms of competitive play for these games, I’m pretty mediocre. My Overwatch rank peaked at Masters in support, but I’m a plat player at heart. As far as Valorant is concerned, I haven’t even attempted ranked to salvage what little confidence I have in my performance.

All that said, I wouldn’t consider myself a casual gamer. I tend to take competitive gaming, including shooters, about as seriously as I take some of my other hobbies like music. And since I’ve been playing for so long, I’ve definitely learned a few lessons that I think translate well to computer programming.

Lessons From Competitive Shooter Games

Given what we chatted about in the opening, I’d have to say that competitive gaming has a lot in common with programming. Sure, programming isn’t exactly competitive in the same sense as a sport, but a lot of the ways you can get better are applicable to both. In this section, we’ll take a look at a few lessons I picked up from shooters that transfer well to getting better at programming.

Learn When to Take a Break

When it comes to doing anything competitive, psychology matters. In the competitive gaming world, we actually have some vocabulary in this space. The language varies by game and community, but there are some general commonalities. For example, when you start to get frustrated while you’re playing, that’s known as getting “tilted” or being “on tilt.” The more tilted you get, the more likely you are to throw a game—meaning you cost your team the game.

Ideally, if you want to win games, you need to be able to roll with the punches. In other words, you don’t want to get too mad or upset when you lose. That way, you can quickly put losses beyond you and move on to the next game.

I find this skill to be fairly practical in programming as well. In other words, if you start to get frustrated when code isn’t working, it’s probably a good time to step away for a bit. Very rarely has anyone solved their problem by beating their head on a desk. You’re more likely to waste more time and grow even more frustrated the longer you stick it out. Come back with a fresh head. Better yet, ask for some help!

Make Your Gear Grow With You

When I was a kid, gaming was pretty straightforward. As long as I had the console and the disk, I could play whatever I wanted. These days I’m more of a PC gamer. As a result, I have to make sure I have the right equipment to enable my success. For example, if I want to be competitive, I need to make sure that my mouse and keyboard are responsive. Likewise, I need a monitor with a high refresh rate and a PC that can handle the games I want to play.

In a lot of ways, programming isn’t much different. In fact, as I write this article, I’m using an incredibly slow Surface Go laptop. It’s not my ideal choice, but it works for writing. That said, I could never use this for gaming, and it’s pretty painful to use while coding. If the tools you use cause you fustration, you’re going to be spending a lot more time taking breaks. Getting the righht gear could minimize that frustration a bit.

That said, I’m not here to be an elitist and say that you need all the best equipment to be a coder. Much like when I first started PC gaming at 6 FPS, you might be coding with a hunk of junk. That’s totally okay! We all start somewhere. In fact, I probably should have mentioned this tip in my music article. After all, I started with a cheap starter horn before I knew I was going to get more serious about music. If you’re not sure you’re going to stick to coding long term, it’s probably not worth the investment to get a nice desktop setup.

Learn to Be a Team Player

Generally, in competitive shooters, there is a team element involved. In some games, teamwork matters more than individual play. A perfect example of this is Overwatch where subtle things like regrouping could mean the difference between winning and losing. Meanwhile in more traditional shooters, you can carry a bit harder by being the best player in the game.

Regardless, there is always going to be a team element in competitive play. This can include things like good communication (i.e. where are the enemies and what’s the plan?) or playing a coherent style as a time. Individually, you can contribute to the bigger whole by being aware of your team and the enemy and making proper callouts. In Overwatch in particular, things like hero selection matters, right? You don’t want to run heroes into their counters. Doing so is a detriment to the team.

As someone who mostly codes alone, these team ideas don’t really apply as directly. However, they do apply to various versions of myself. For example, documenting code is important because it helps my future self with development. Similar arguments could be made about technical debt and other things that contribute to work in the long term.

That said, if you work on a team, there are certainly things you can be doing to benefit the greater whole. Of course, you need to keep proper boundaries, so there’s a balance. Generally, I think communication is an important skill that can make you more of a team player. These applies in both competitive shooters and programming because it can alleviate a lot of confusion, and confusion can be the enemy of progress.

Don’t Forget Your Objective

In my experience, shooters are very rarely just about getting picks. In Overwatch, there is no deathmatch game mode beyond arcade. In Call of Duty, there are various objective modes including my personal favorite: Search & Destroy. Meanwhile, Valorant’s main game mode is just another form of Search & Destroy. Also, I’m a huge fan of capture the flag and king of the hill: both of which appear in some form in just about every shooter I’ve played.

In all of these games, playing the objective matters. In theory, you could probably get away with neglecting the objective if you could keep the enemy completely contained, but it usually does you better to do both at the same time. Being able to do both requires coordination and awareness that takes time to learn and develop.

From a programming perspective, objectives matter. A lot of times, you can really get lost in the weeds by pursuing little bugs or features that aren’t contributing to the greater objective. This can cause you to fall behind or worse: break things. Generally, the team will appreciate you more if you can keep your eye on the prize. The way I do this is by making sure the team assigns priority to certain tasks. That way, I know which order to attack the tasks, so I can stay organized and productive.

Funnily enough, I’ve personally thrown games and projects by forgetting about the objective. In the Overwatch world, we have a hilarious term for this: C9. Here’s the context:

Moral of the story is: don’t forget your objective.

What Else Can Programmers Borrow?

Once again, for my programmer friends out there, how did I do? Did you pick up any new ways to practice coding? Are you interested in exploring competitive shooters? Were you surprised by any of the connections I made?

For my gamer friends out there, what did I miss? Are there other practice techniques that you think can transfer over to programming? Do you do anything like this? How else has gaming helped your programming career?

With all that said, I’m going to wrap this one up for the day. If you liked this article and would like to see more like it, feel free to head over to my list of ways to grow the site. There you’ll find links to my Newsletter as well as our Discord Server and Patreon page. Otherwise, thanks for sticking around!

How to Get Better at Programming: Lessons From Music

Jeremy Grifski — Fri, 12 Mar 2021 18:58:51 +0000

Recently, I was writing an article about practice problems in Python when I started to go off on a tangent about music. The idea was that a lot of the skills I learned in music could be translated to programming. Then, I realized that there are probably a ton of skills I’ve picked up over the years that translate well into programming. As a result, consider this the first post in a series about my love of learning new things.

Music Expertise

As some of you might know, I’ve been playing trombone for quite a number of years—though it wasn’t my first instrument. I picked it up back in late 2005 when I had just entered 6th grade. I think that puts me now at almost 16 years of experience.

These days, I’m not as serious about music as I used to be. That said, prior to the pandemic, I had been attending a weekly ensemble in Columbus. Before that, I played in middle school, high school, and college. For instance, here’s an embarrassing clip of me playing a mediocre solo in high school:

In all that time, I feel like I’ve learned a thing or two about how to get better at music—though I’m no expert. As a result, I figured I’d share some of the practice skills I’ve learned through music and how they could map to a skill like programming.

Borrowing Practice Skills From Music

I won’t get too deep into philosophy, but I feel like our society prioritizes specialization too much. I try to reflect this belief as much as possible in my daily life by engaging in new topics and activities regularly. For instance, I recently picked up chess, and I’ve started playing RPGs for the first time in awhile. Naturally, one of those skills I’ve picked up is music.

Music is interesting because it’s surprisingly similar to programming. In fact, I’ve made this argument before while talking about programming language classification. If programming is getting a computer to behave a certain way through a shared language, is music not similar? Instead of using Python, musicians use common music notation.

As a result, I see music to be similar to programming in a lot of ways. For instance, contrary to popular belief, I think programming is a creative endeavor. There are a lot of choices you get to make which are decided through your own style. Not to mention that creating stuff is inherently a creative process.

All that aside, I thought today we could talk about ways to get better at programming using some of the practice techniques I’ve seen in music. Specifically, there are three skills I can think of that map quite nicely to programming: transcription, transposition, and sight reading. Certainly, there are musicians in the crowd that can back me up on this!

Transcription == Reverse Engineering

One of the skills I’ve learned from music is transcription. If you’re not familiar with what that means in the context of music, it’s basically the process of converting audio into sheet music. Typically, this is done by ear with helpful tools nearby like a piano.

Transcription is a useful practice technique for a variety of reasons. First, it forces you to listen carefully to not just rhythm and harmony but also dynamics and tempo. Of course, these are just the mechanics by which music is written. Throughout the transcription process, you can also pickup on patterns and style. These can provide inspiration if you ever decide to write your own music or develop your own style.

At this point, however, you’re probably wondering how transcription is at all related to programming. Certainly, you can’t “hear” a program and turn it into code, right? Of course not! That said, you can observe the behavior of a program and try to replicate it. This is known as reverse engineering.

As far as I know, reverse engineering is very common way to learn web development. Want to know how to make a social media site? Try replicating Facebook or Twitter. Unfortunately, this can be a bit more challenging in more obscure fields like data science and machine learning. Of course, if you’re relatively new to programming, you might try to replicate common built-in functions in your favorite language. I do this in my “Roll Your Own Python” series, so you might enjoy doing something similar.

Transposition == Substitution

One skill I tried to pick up in college was transposition (i.e. the process of changing the pitches in a song by some interval). This was a technique that was recommended to me as a way to get better at trombone. All I had to do was transpose my favorite piece into all 12 keys and keep playing it.

Having never actually attempted this, I don’t know for sure what the value of something like this would provide, but I can speculate. First, the process of transposition is likely not a skill you can do naturally. As a result, the process of doing it by hand several times may build up your skills to do it automatically in your head. Second, transposition provides a new piece of music on the other side which may test your range (e.g., highest notes get higher and lower notes get lower). Since you likely know the rhythms quite well, there is more effort that can go into developing your range. Finally, each key comes with a new scale that you can implicitly practice in a more fun way.

So, how does this map to programming? I think of transposition as solving a programming problem multiple different ways. At the end of the day, the program still does the same thing, so you can substitute any solution you’d like.

In terms of practice, this might look like finding a programming problem and thinking of as many ways as possible to solve it. I’m a big fan of this in general because it teaches you to respect different ideas and approaches. That said, it’s also a great way to learn. For instance, if you have a problem that requires a data structure, try solving it with different data structures. Then, for an added bonus, compare the results. Are all the solutions the same? Or do some run faster than others? How do they scale?

Sight Reading == Proof of Concept

I’ve always been a “play it by hear” musician, so one of my worst skills has been sight reading. If you’re not familiar with this concept, sight reading is when you sit down to read a piece of music for the first time. Usually, I’d have to hear the music before I could play it. That said, if I could sight read, I could bypass the listening part altogether.

Regardless of how I feel about sight reading, more serious musicians would probably argue that it’s an important skill. In fact, there are a ton of competitions that include sight reading as one of the core competencies (see: adjudication). Outside of that, it’s just a nice skill to have, so you can get up and running quicker in an ensemble. Or if you’ve ever been in a small group, you’ve probably played a few songs live from an enormous book that you only practiced from once or twice (e.g. every holiday quartet ever).

From a programming standpoint, I could see sight reading being interpreted in a couple ways. First, there’s the skill of being about to read code and tell what it does. Then, there’s the ability to read requirements and convert them into code. I see sight reading a bit more like the latter. After all, you’re never really expected to play something perfectly when you sight read—it’s more like a proof of concept.

I suppose that’s where resources like HackerRank come in. Given a prompt for a random coding challenge, can you come up with a quick solution? The point being that you’re practicing the translation process between a set of requirements and actual code. Here, you’re not trying to write the best solution or even a good one; you just want a proof of concept.

What Else Can Programmers Borrow?

For my programmer friends out there, how did I do? Did you pick up any new ways to practice coding? Are you interested in exploring music? Were you surprised by any of the connections I made?

For my music friends out there, what did I miss? Are there other practice techniques that you think can transfer over to programming? Do you do anything like this? How else has music helped your programming career?

With that said, that’s all I have for now! I’m interested in making this a recurring series as I have many different hobbies and interest. For instance, I’d definitely like to map programming and gaming sometime. Do you have any skills or hobbies that you’d like featured. Let me know!

Otherwise, thanks for stopping by. Feel free to take some time to stop and support the community here.

Can We Fit Rock Paper Scissors in Python in a Tweet?

Jeremy Grifski — Tue, 03 Nov 2020 03:19:57 +0000

If you’ve followed me on this saga to shrink my original behemoth of a solution to Rock Paper Scissors, then you know we’ve moved 1,389 characters down to 864 by introducing modular arithmetic. Then, we shrunk the program again down to 645 characters through some refactoring. Now, we’re going to try to get the program down to the size of a tweet or 280 characters. Can it be done?

This article is not clickbait. It is absolutely possible to write Rock Paper Scissors in 280 characters, and I did it! That said, I don’t think it’s possible without making some sacrifices to the original requirements.

At any rate, let’s get started!

Where Did We Leave Off?

At this point in time, here’s the latest version of the program:

import random

# Generate default outcome
choices = ["Rock", "Paper", "Scissors"]
pc_index = random.randint(0, 2)
pc_choice = choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]

# Play game
user_pick = input("Choose Rock (0), Paper (1), or Scissors (2): ")
if user_pick.isdecimal() and (user_index := int(user_pick)) in range(3):
  user_choice = choices[user_index]
  output[1:] = [
    f"You chose {user_choice}", 
    [
      "Tie!", 
      f"{user_choice} beats {pc_choice} - you win!", 
      f"{pc_choice} beats {user_choice} - I win!"
    ][(user_index - pc_index) % 3]]

# Share outcome
print("\n".join(output))

Currently, our program sits comfortably at 644 characters, and it’s still very readable. Ultimately, what I want to do now is exploit a few things that can be found in my obfuscation article—namely remove spaces and shorten variable names. In addition, we’re going to try a few tricks in this code golf thread. Let’s get started!

Begin Compression

Throughout the remainder of this article, I’ll be documenting my entire process for trying to shrink Rock Paper Scissors down to 280 characters (a.k.a. the size of a tweet).

As a quick warning, compressing code by hand is a long and messy process, and there are definitely better ways to go about it. That said, one of the things that I find missing in education is “expert” rationale. I’m not considering myself an expert here, but I think it’ll be valuable to see my approach to problem solving.

And if nothing else, you can watch me struggle to get this done! Don’t worry. I manage to get it down to tweet size —not without a few bumps along the way.

Iterable Unpacking

One of the very first suggestions in that code golf thread is to take advantage of iterable unpacking when assigning variables. In our case, we have several variables assignments at the top that we might try merging. For example, we might take the following:

choices = ["Rock", "Paper", "Scissors"]
pc_index = random.randint(0, 2)
pc_choice = choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]

And, turn it into this:

choices, pc_index, pc_choice, output = ["Rock", "Paper", "Scissors"], random.randint(0, 2), choices[pc_index], [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]

Sadly, this doesn’t really have the payoff I was expecting. Perhaps because the answer I’m referencing uses a string as the iterable. That said, I’m determined to squeeze some sort of payoff out of this, so I’m going to try to restructure it:

*choices, pc_index, pc_choice = "Rock", "Paper", "Scissors", random.randint(0, 2), choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]

Okay, so this was a bit of a let down, but it might help us later. Let’s retain the original program for now and try something else!

Rewriting Input String

Since all of our choices are stored in a list, I figured we could try dynamically generating the input string. Perhaps that would be a bit cleaner. In other words, instead of writing this:

user_pick = input("Choose Rock (0), Paper (1), or Scissors (2): ")

We could write something like this:

user_pick = input(f'{", ".join(choices)}! (0, 1, 2):')

Now, that’s some savings! It’s not quite as explicit as the original, but we’re going for compression. I’ll take 54 characters over 66 any day. Here’s what the program looks like now:

import random

# Generate default outcome
choices = ["Rock", "Paper", "Scissors"]
pc_index = random.randint(0, 2)
pc_choice = choices[pc_index]
output = [f"I chose {pc_choice}", "You chose nothing.", "You lose by default."]

# Play game
user_pick = input(f'{", ".join(choices)}! (0, 1, 2):')
if user_pick.isdecimal() and (user_index := int(user_pick)) in range(3):
  user_choice = choices[user_index]
  output[1:] = [
    f"You chose {user_choice}", 
    [
      "Tie!", 
      f"{user_choice} beats {pc_choice} - you win!", 
      f"{pc_choice} beats {user_choice} - I win!"
    ][(user_index - pc_index) % 3]]

# Share outcome
print("\n".join(output))

Now, we’re down to 653! Don’t worry; bigger changes are ahead.

Renaming the Import

At this point, I don’t think there is any way around using the random library. That said, we can give it a name which could save us a couple characters. In other words, instead of rocking this:

import random
pc_index = random.randint(0, 2)

We could try something like this:

import random as r
pc_index = r.randint(0, 2)

Unfortunately, a change like this doesn’t actually save us any characters: 45 no matter how you slice it! That said, this may have worked if we used random multiple times.

Renaming All Variables

At this point, I don’t see any value in trying to play with the existing code. Let’s go ahead and shrink all our variables and optimize on the other end if we’re still out of range. Here’s what that would look like:

import random

# Generate default outcome
a = ["Rock", "Paper", "Scissors"]
b = random.randint(0, 2)
c = a[b]
d = [f"I chose {c}", "You chose nothing.", "You lose by default."]

# Play game
e = input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f := int(e)) in range(3):
  g = a[f]
  d[1:] = [
    f"You chose {g}", 
    [
      "Tie!", 
      f"{g} beats {c} - you win!", 
      f"{c} beats {g} - I win!"
    ][(f - b) % 3]]

# Share outcome
print("\n".join(d))

Now, we’re down to 470 characters! How’s that for savings? We’re on our way to tweet size. Up next, let’s try removing all the comments and empty lines.

Removing Comments and Empty Lines

Another quick change we can make is the removal off all comments and empty lines. That way, we just get a wall of code like this:

import random
a = ["Rock", "Paper", "Scissors"]
b = random.randint(0, 2)
c = a[b]
d = [f"I chose {c}", "You chose nothing.", "You lose by default."]
e = input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f := int(e)) in range(3):
  g = a[f]
  d[1:] = [
    f"You chose {g}", 
    [
      "Tie!", 
      f"{g} beats {c} - you win!", 
      f"{c} beats {g} - I win!"
    ][(f - b) % 3]]
print("\n".join(d))

Unfortunately, this only buys us another 58 characters. Now, we’re sitting at 412 characters. How will we ever cut another 132 characters? Well, we can start trimming away spaces.

Eliminating Extraneous Spaces

At this point, I’m starting to grasp at straws, so I figured we could try removing any unnecessary spaces. For example, do we really need spaces around our assignment operators? Of course not! See:

import random
a=["Rock","Paper","Scissors"]
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):
  g=a[f]
  d[1:]=[f"You chose {g}",["Tie!",f"{g} beats {c} - you win!",f"{c} beats {g} - I win!"][(f-b)%3]]
print("\n".join(d))

Now, this really does a number on the total count. Unfortunately, it’s not quite enough! We’re only down to 348 characters. How will we shave off another 68? Well, since we’re on the topic of removing extra spaces, how about in our winner strings? Take a look:

import random
a=["Rock","Paper","Scissors"]
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):
  g=a[f]
  d[1:]=[f"You chose {g}",["Tie!",f"{g} beats {c}—you win!",f"{c} beats {g}—I win!"][(f-b)%3]]
print("\n".join(d))

That shaves off another four characters! Now, we’re just 64 away from freedom (i.e. 344 in total), and I have a couple ideas.

Crushing Branches

One idea I had was to see if we could reduce the if statement into a single line. To do that, we’ll need to remove the creation of g. The result looks like this:

import random
a=["Rock","Paper","Scissors"]
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=[f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]]
print("\n".join(d))

Unfortunately, it seems g was doing a lot of the heavy lifting because this only shaved off a couple characters! Oh well, we’re down to 341. What else can we do?

Removing Redundant Brackets

At this point, I’m really running out of options. That said, one idea I had was to remove any brackets that weren’t doing anything useful. For example, our a list stores the choices of Rock Paper Scissors. Surely, we can turn that into a tuple, right? Well, here’s to saving two more characters:

import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=[f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]]
print("\n".join(d))

Unfortunately, similar ideas can’t be used on the d list. That said, the list used in slice assignment can absolutely be trimmed:

import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))

From here, though, there doesn’t appear to be any lists that we can trim. That said, we’ve saved even more characters. Now we’re down to 337! Can we achieve 280?

Reducing Redundant Strings

At this point, I had an ephany! What if we referenced d when building the successful game string? In other words, why type out “You chose” twice when we can extract it from d? Here’s what that would look like:

import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=f"{d[1][:10]}{a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))

Sadly, this bit of trickery actually costs us a character. Even in the best case scenario, we’d only break even. So, what if instead we just saved “You chose” into a variable? Here’s the result:

import random
a="Rock","Paper","Scissors"
b=random.randint(0,2)
c=a[b]
g="You chose "
d=[f"I chose {c}",f"{g}nothing.","You lose by default."]
e=input(f'{", ".join(a)}! (0, 1, 2):')
if e.isdecimal() and (f:=int(e)) in range(3):d[1:]=f"{g}{a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))

Again, we lose a couple characters! Perhaps if these strings weren’t so short, we’d get some type of savings, but this has been a huge letdown so far. Let’s try something else!

Removing Function Calls

With 57 characters to shave, I’m not sure we’ll meet our goal. However, we can keep trying. For instance, I already know a place where we can trim a couple characters. And, I might even let it serve double duty! Let’s go ahead and remove our call to range():

import random
a="Rock","Paper","Scissors"
g=0,1,2
b=random.choice(g)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! {g}:')
if e.isdecimal() and (f:=int(e)) in g:d[1:]=f"You chose {a[f]}",["Tie!",f"{a[f]} beats {c}—you win!",f"{c} beats {a[f]}—I win!"][(f-b)%3]
print("\n".join(d))

By storing our choices as a tuple, we were able to delete our call to range(). At the same time, I saw an opportunity to replace part of the input string with our new tuple. Even better, we no longer have to use the randint() function of random. Instead, we can pull a random choice from our tuple. Talk about triple duty!

While this is very exciting, we only managed to save 8 characters (i.e. 329 in total). With 49 to go, I’m not sure we’re going to hit our goal, but we can keep trying!

Converting Lists to Strings

One thing I thought we could try that might be slightly more drastic would be to overhaul d, so it’s a string rather than a list. In other words, if we can somehow get rid of the need for lists, we can drop the call to join() and print out the string directly. I think it’s worth a shot! Here’s what that would look like:

import random
a="Rock","Paper","Scissors"
g=0,1,2
b=random.choice(g)
c=a[b]
d=f"I chose {c}\nYou chose nothing.\nYou lose by default."
e=input(f'{", ".join(a)}! {g}:')
if e.isdecimal() and (f:=int(e)) in g:d=f"{d[0:9+len(c)]}You chose {a[f]}\n{['Tie!',f'{a[f]} beats {c}—you win!',f'{c} beats {a[f]}—I win!'][(f-b)%3]}"
print(d)

Despite this change, we only manage to save a single character. Instead, let’s try something else!

Another idea I had was to try using a string list instead of a numeric list of g. One of the main problems with this program is that we have to validate the input. Perhaps the easiest way to validate it is to check for the three values we expect directly. In other words, make g store strings and convert them back to integers as needed:

import random
a="Rock","Paper","Scissors"
*g,='012'
b=random.randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! {g}:')
if e in g:d[1:]=f"You chose {(f:=a[int(e)])}",["Tie!",f"{f} beats {c}—you win!",f"{c} beats {f}—I win!"][(int(e)-b)%3]
print("\n".join(d))

Surprisingly, this actually works! By cleaning up our if statement, we managed to save another 14 characters. Now, we’re down to 315. Can we remove 35 more?

Using Walrus Operators Everywhere

Another idea I had was to use walrus operators in the place of traditional assignment. Unfortunately, this doesn’t seem to actually save any characters because the walrus operator has an extra character. In addition, it often has to be embedded in parentheses to work. That said, I gave it a shot for fun!

import random
*g,='012'
d=[f"I chose {(c:=(a:=('Rock','Paper','Scissors'))[(b:=random.randint(0,2))])}","You chose nothing.","You lose by default."]
if (e:=input(f'{", ".join(a)}! {g}:')) in g:d[1:]=f"You chose {(f:=a[int(e)])}",["Tie!",f"{f} beats {c}—you win!",f"{c} beats {f}—I win!"][(int(e)-b)%3]
print("\n".join(d))

Now, this is a complete nightmare! But, surprisingly, there’s not a ton of additional baggage. As far as I can tell, this brings us back to 321 characters, and it works. So, let’s backtrack!

Taking Advantage of the Import

While reading through that code golf thread, I found this gem. Rather than importing random and using it, I can import all things random and save a character:

from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
d=[f"I chose {c}","You chose nothing.","You lose by default."]
e=input(f'{", ".join(a)}! {g}:')
if e in g:d[1:]=f"You chose {(f:=a[int(e)])}",["Tie!",f"{f} beats {c}—you win!",f"{c} beats {f}—I win!"][(int(e)-b)%3]
print("\n".join(d))

It’s not much, but we’re totally in “not much” territory. In other words, with 34 characters to go, a single character might be all we need!

Revisiting String Manipulation

A few sections ago I had mentioned that converting the lists to strings didn’t pay off. Well, I found a way to make it work!

from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
h=" chose "
d=f"I{h}{c}\nYou{h}nothing\nYou lose by default"
e=input(f'{", ".join(a)}—{g}:')
if e in g:d=f"I{h}{c}\nYou{h}{(f:=a[int(e)])}\n{['Tie',f'{f} beats {c}—you win',f'{c} beats {f}—I win'][(int(e)-b)%3]}"
print(d)

Previously, I had some slicing nonsense that required a computation to get right. This time around, I figured we could replicate the strings exactly. Then, replace duplicate words with a variable. And, somehow, it worked!

Now, we’re sitting pretty at 301 characters. We’re getting dangerously close to 280, and I’m starting to get excited.

From here, I started thinking: “what would happen if we started removing some of the duplication in the strings?” Well, it didn’t work out:

from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
h,i,j,k,n="chose "," beats ","You ","I ","\n"
l=k+h+c+n+j+h
d=f"{l}nothing{n+j}lose by default"
e=input(f'{", ".join(a)}—{g}:')
if e in g:d=f"{l}{(f:=a[int(e)])}\n{['Tie',f'{f+i+c+n+j}win',f'{c+i+f+n+k}win'][(int(e)-b)%3]}"
print(d)

Not only is this ridiculously unreadable, but it’s also a larger program than before. So, I scrapped it and started from the previous version.

Reworking User Prompts

At this point, I felt sort of defeated, so I decided to remove language from the game strings. For example, instead of saying “You”, the program says “U”. In the end, it came down to having a little bit of fun with it:

from random import*
a="Rock","Paper","Scissors"
*g,='012'
b=randint(0,2)
c=a[b]
h=" chose "
d=f"I{h}{c}\nU{h}death\nI win"
e=input(f'{", ".join(a)}!—{g}:')
if e in g:d=f"I{h}{c}\nU{h}{(f:=a[int(e)])}\n{['Tie',f'{f} beats {c}—u win',f'{c} beats {f}—I win'][(int(e)-b)%3]}"
print(d)

In other words, I basically let go of having exactly the same output. For example, I was able to swap words like “You” to “U” and “Nothing” to “Death”. In a sort of endearing way, I feel like these changes make the program better: it makes me feel like an edgy teen.

That said, the true magic of these changes is we’ve managed to squash the program from 301 characters to exactly 280. That’s it! That’s Rock Paper Scissors in a tweet.

Lessons Learned

Pretty much the moment I got this code down to 280 characters, I went ahead and posted it:

// Detect dark theme var iframe = document.getElementById('tweet-1311450233717563401-639'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1311450233717563401&theme=dark" }

That said, as you can see, I’m not sure all the effort was worth it. At best, two of my friends found it funny, but I’m not sure it’s something I’ll do again. Honestly, there’s only so much meme value you can get out of something like this, and it just didn’t hit like I expected.

Of course, if you thought this was funny and you’d like to do something similar, let me know! I’d love for a silly challenge like this to take over social media for a day or two. And if not, no worries! I had fun trying to do this.

Also, I know this article is kind of messy, so let me know if you’d like me to distill some of what I’ve learned into another article. It would enjoy doing that! But, only if it’s what you want to read. It’s certainly not something people are going to search on Google.

At any rate, thanks again for sticking it out with me! In case you missed it, here are the articles that inspired this one:

Finally, if you’d like to support the site directly, here’s a list of ways you can do that. Otherwise, thanks for stopping by! Take care.

Does Anyone Still Code Golf? The 280 Character Challenge

Jeremy Grifski — Thu, 01 Oct 2020 03:02:26 +0000

Awhile back, I had written a program to play Rock Paper Scissors in Python. It's a pretty simple program, but I really liked how eloquent the solution was.

Flash forward a couple years and you'll find me, two years into a PhD program looking for anything to do but read more research. While browsing Twitter, I saw a tweet asking folks to share their favorite technical article:

// Detect dark theme var iframe = document.getElementById('tweet-1310692783909416961-379'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1310692783909416961&theme=dark" }

Now, I've been consistently writing two articles a week for the last four years, so I've amassed quite the collection of articles. But, for some reason, that article on Rock Paper Scissors is one that always sparks joy, so I decided to revisit it.

As many of you know, revisiting your old work is always a little weird. In this case, part of me was really excited to read it again because there's obviously a bit of nostalgia associated with it. Unfortunately, as I've learned while playing Super Mario 64 recently, sometimes you remember things as better than they were.

Well, when I was reading through that article, I noticed that there were ways I wrote the code that I wouldn't today. It was nothing major, but there were definitely things I would change.

Of course, instead of editing the existing article, I decided to start a new one. This one would pick up where the last one left off two years ago.

That said, instead of writing an article where I would slightly modify the code, I thought it would be fun to take a code golf approach. In other words, how small could I make the program while still maintaining some readability.

Unfortunately, when you go down this road, there's only one place it leads: incomprehensible code in as few characters as possible.

While laying in bed after managing to shrink the program 25%, I had an idea: how cool would it be if I could shrink the program down to 280 characters, so I could post it in its entirety on Twitter?

Alright, so maybe late night ideas aren't that great, but I went through with it anyway. Here's what that looks like:

// Detect dark theme var iframe = document.getElementById('tweet-1311450233717563401-551'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1311450233717563401&theme=dark" }

It's pretty wild, but those 280 characters are enough to execute a Rock Paper Scissors game in Python 3.8 against a computer. Go ahead! Try it!

The Sample Programs Repos Are Ready for Hacktoberfest 2020

Jeremy Grifski — Mon, 21 Sep 2020 19:17:25 +0000

This year, I decided to prepare for Hacktoberfest a bit early. In other words, you could say that the Sample Programs repositories are ready to go for Hacktoberfest 2020.

What Is the Sample Programs Repo?

For the uninitiated, the Sample Programs repo is a collection of code snippets in as many programming languages as possible. This was a project I kicked off in early 2017, and I’ve largely benefited from the effort of folks during the previous Hacktoberfests to grow the collection to its current size:

468 code snippets
284 forks
260 stars
120 programming languages
30 projects
21 test suites

A lot of folks have been justifiably skeptical of this collection over the years. After all, when something like Rosetta Code already exists, what’s the point in creating a clone?

In the past, my argument revolved around two things. First, it’s okay for similar things to exist in the world because they cater to different individuals. Second, since my project is a lot smaller, it leaves a lot of room for community-driven growth.

That second point is what prompted a lot of change in the repo over the years. For example, many of the code snippets now have documentation in the form of a blog article. This is not the case with Rosetta Code. Likewise, many of the code snippets are tested based on a rigorous set of project standards. I assume Rosetta Code does this, but I’m not sure.

That said, regardless of if you appreciate my argument, I believe a lot of folks have and will continue to get a lot of value out of this collection. In the next section, we’ll talk about how the repo has been prepared for Hacktoberfest 2020.

How Has the Sample Programs Repos Prepared for Hacktoberfest 2020?

If there’s anything you take away from this update, it should be that the Sample Programs repo is now a set of repos. One of the things that had been bothering me is just how unwieldy the repo had grown in the past couple years. At one point, we were storing everything in it from articles to test code to wiki generation code.

Now, I’ve taken the time to pull this repo apart, so it’s a bit easier to manage:

Sample Programs: just code snippets and tests
Sample Programs Website: all the website code and all the code snippet documentation
Sample Programs Wiki Generator: all the code for generating the Sample Programs wiki

To do this, I had to move the docs folder of the Sample Programs repo into its own repo. Then, I moved all the article related issues to the new repo. In addition, I updated the contribution docs and the main README, so everything is a bit more streamlined.

As the maintainer, I feel like the biggest benefit will be project management. Now, when someone wants to add a code snippet, I just have to point them to the projects page of the website.

In addition, another huge benefit of this will be build times for the website. Previously, if we made a change to the website, we’d have to wait for all the code snippets to be validated first. This was a pain, and it completely slowed down the pipeline. Now with the articles separated out, we can make changes to the website much quicker.

Hopefully, these changes will encourage folks like you to begin helping out!

How Can I Help Out?

By the time this article is published, we’ll have about 10 days until Hacktoberfest 2020 officially begins. My request in that time is that you look over the list of currently supported projects or jump straight into the list of open issues (e.g. Sample Programs or Website). From there, you have basically four options:

Pick a project and begin implementing solutions in various programming languages (e.g. Fibonacci in Perl)
Pick a project that currently doesn’t have testing and write your own (e.g. Linear Search Testing)
Pick a language that currently doesn’t have testing and write your own (e.g. MATLAB Testing)
Come up with a new project and write documentation for it (e.g. Palindrome in Every Language)

All four options help grow the repo, but keep in mind that some options will increase the complexity of the repo. For example, adding a project opens the door for 120+ more code snippets. That said, for people who want to write code snippets for some of the more popular languages like Python and JavaScript, coming up with your own project is pretty much your only option. Likewise, adding tests will slow down build times.

Alternatively, you’re always welcome to write documentation for existing articles. This is something that has really not gotten the support it deserves. As a result, I plan to incentivize it a bit by sharing your article on my website if you’d like.

Beyond that, I’m open to anything. One of the best things about having community-driven project like this is I’ve always been able to watch the project grow and change over time. This year I expect this trend to continue!

Best of Luck!

If you haven’t had a chance to take part in Hacktoberfest up until this year, that’s okay! I personally haven’t contributed to a repo other than my own. Perhaps you might try starting your own project as well.

That said, if you do decide to help out with the Sample Programs collection, I’d really appreciate it. Otherwise, no hard feelings! Even if you don't decide to help, you can track all the progress in our Discord! The Discord is open to anyone—even folks who just want to chat tech, life, or whatever.

While you’re waiting for Hacktoberfest 2020 to kick off, why not check out some of my other articles. For instance, I recently started a Python series for folks looking to learn the language. Here are a few to get you started:

Once again, thanks for taking some time to stop by! I appreciate it.

How to Add an Item to a List in Python: Append, Slice Assignment, and More

Jeremy Grifski — Sun, 26 Jul 2020 03:59:12 +0000

Lately, I’ve been thinking about new Python topics to write about, so I took to Google. When I searched “Python how to”, “Python how to add to a list” popped up first. Since this must be a popular search term, I decided it was worth an article. In other words, today we’ll learn how to add an item to a list in Python.

To save you some time, you can start adding items to a list right now with the append() method: my_list.append(item). If you have more complex needs, consider using extend(), insert(), or even slice assignment. See the rest of the article for more details.

Problem Description

For people who come from other programming languages, tasks like creating and adding to a list can be daunting. After all, almost every language supports lists in one form or another (e.g. arrays, lists, etc.), but not all languages have the same syntax. For instance, here’s an example of an array in Java:

int[] myArray = new int[10];
myArray[0] = 5; // [5, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Here, we’ve created a fixed-size array of 10 elements, and we’ve set the first element to 5. In other words, we don’t really add elements to arrays in Java. Instead, we modify existing elements.

Meanwhile, in a language like Rust, arrays are declared a little differently:

let mut my_array: [i32; 10] = [0; 10];
my_array[0] = 5; // [5, 0, 0, 0, 0, 0, 0, 0, 0, 0]

In Rust, we have to explicitly declare the array as mutable with mut. That way, we can modify the array just like in Java. In addition, the syntax is quite a bit different. For example, we set the type to i32, the size to 10, and all elements to 0.

Of course, there are languages with built-in lists much similar to what you might find in Python. For example, Ruby’s (dynamic) arrays can be created and modified as follows:

my_array = []
my_array << 5 # [5]

Unlike the previous solution, we didn’t have to setup our array with a certain size. Instead, we’re able to start with an empty array. Then, we pushed a 5 into the array, and called it a day.

Oddly enough, in Python, the syntax for creating a list is quite similar:

my_list = []

But, how do we add anything to this list? That’s the topic of this article.

Solutions

In this section, we’ll take a look at various ways to add an item to a list in Python. Since this task is pretty straightforward, there aren’t very many options. In fact, that’s sort of by design in Python (i.e. “There should be one– and preferably only one –obvious way to do it.”). That said, I’ve included a few silly solutions to keep this piece interesting.

Add an Item to a List Statically

To be honest, this is sort of a nonanswer. That said, if you want to populate a list, you can declare the elements statically:

my_list = [2, 5, 6]

Rather than adding the items one at a time, we’ve decided to initialize the list exactly as we want it to appear. In this case, we’ve created a list with three items in it: 2, 5, and 6. In the next section, we’ll look at our first way to modify an existing list.

Add an Item to a List by Slice Assignment

In Python, there is this very peculiar piece of syntax that I only just recently learned about called slice assignment. While slicing can be used to return a section of a list, slice assignment can be used to replace a section of a list. In other words, it’s possible to write an expression which adds a value to the end of a list:

my_list = []
my_list[len(my_list):] = [5]

Here, we have an expression which replaces the end of the list, which is an empty list, with a list containing a single value. In essence, we’ve added an item to the end of the list.

Interestingly enough, this syntax can be used to replace any part of a list with any other list. For example, we could add an item to the front of the list:

my_list = [1, 2, 3, 4] 
my_list[:0] = [0] # [0, 1, 2, 3, 4]

Likewise, we can replace any sublist with any other list of any size:

my_list = [1, 2, 3, 4] 
my_list[:2] = [6, 7, 8, 9] # [6, 7, 8, 9, 3, 4]

Fun fact: we aren’t restricted to lists with this syntax. We can assign any iterable to the slice:

my_list = []
my_list[:] = "Hello" # ['H', 'e', 'l', 'l', 'o']
my_list[:] = (1, 2, 3) # [1, 2, 3]
my_list[:] = (i for i in range(5)) # [0, 1, 2, 3, 4]

When I first added this solution to the list, I thought it was kind of silly, but now I’m seeing a lot of potential value in it. Let me know if you’ve ever used this syntax and in what context. I’d love to see some examples of it in the wild.

Add an Item to a List with Append

On a more traditional note, folks who want to add an item to the end of a list in Python can rely on append:

my_list = []
my_list.append(5)

Each call to append will add one additional item to the end of the list. In most cases, this sort of call is made in a loop. For example, we might want to populate a list as follows:

my_list = []
for i in range(10): 
  my_list.append(i)

Of course, if you’re going to do something like this, and you’re not using an existing list, I recommend using a list comprehension:

my_list = [i for i in range(10)]

At any rate, append() is usually the go-to method for adding an item to the end of a list. Of course, if you want to add more than one item at a time, this isn’t the solution for you.

Add an Item to a List with Extend

If you’re looking to combine two lists, extend() is the method for you:

my_list = []
my_list.extend([5])

In this example, we append a list of a single element to the end of an empty list. Naturally, we can append a list of any size:

my_list = [3, 2]
my_list.extend([5, 17, 8]) # [3, 2, 5, 17, 8]

Another great feature of extend() is that we’re not restricted to lists; we can use any iterable. That includes tuples, strings, and generator expressions:

my_list = []
my_list.extend("Hello") # ['H', 'e', 'l', 'l', 'o']
my_list.clear()
my_list.extend((1, 2, 3)) # [1, 2, 3]
my_list.clear()
my_list.extend(i for i in range(5)) # [0, 1, 2, 3, 4]

Of course, like append(), extend() doesn’t return anything. Instead, it modifies the existing list. Also like append(), extend() only adds the iterable to the end of the other list. There’s no way to specify where the input iterable goes. If you want more control, I suggest slice assignment or our next method, insert().

Add an Item to a List with Insert

If append() and extend() aren’t doing it for you, I recommend insert(). It allows you to add an item to a list at any index:

my_list = []
my_list.insert(0, 5)

In this case, we inserted a 5 at index 0. Naturally, we can choose any valid index:

my_list = [2, 5, 7]
my_list.insert(1, 6) # [2, 6, 5, 7]

And just like with regular list syntax, we can use negative indices:

my_list = [2, 5, 7]
my_list.insert(-1, 9) # [2, 5, 9, 7]

How cool is that?! Unfortunately, however, we can’t really insert an entire list. Since Python lists don’t restrict type, we can add any item we want. As a result, inserting a list will literally insert that list:

my_list = [4, 5, 6]
my_list.insert(1, [9, 10]) # [4, [9, 10], 5, 6]

Luckily, slice assignment can help us out here!

Performance

With all the solutions ready to go, let’s take a look at how they compare in terms of performance. Since each solution doesn’t do exactly the same thing, I’ll try to be fair in how I construct my examples. For instance, all the following examples will append a value at the end of each of the sample lists (ignoring the static assignment solutions):

setup = """
empty_list = []
small_list = [1, 2, 3, 4]
large_list = [i for i in range(100000)]
"""

static_list_empty = "empty_list = []"
static_list_small = "small_list = [1, 2, 3, 4, 5]"

slice_assignment_empty = "empty_list[len(empty_list):] = [5]"
slice_assignment_small = "small_list[len(small_list):] = [5]"
slice_assignment_large = "large_list[len(large_list):] = [5]"

append_empty = "empty_list.append(5)"
append_small = "small_list.append(5)"
append_large = "large_list.append(5)"

extend_empty = "empty_list.extend([5])"
extend_small = "small_list.extend([5])"
extend_large = "large_list.extend([5])"

insert_empty = "empty_list.insert(len(empty_list), 5)"
insert_small = "small_list.insert(len(small_list), 5)"
insert_large = "large_list.insert(len(large_list), 5)"

Now, let’s take a look at all the empty list examples:

>>> import timeit
>>> min(timeit.repeat(setup=setup, stmt=static_list_empty))
0.06050460000005842
>>> min(timeit.repeat(setup=setup, stmt=slice_assignment_empty))
0.4962195999996766
>>> min(timeit.repeat(setup=setup, stmt=append_empty))
0.17979939999986527
>>> min(timeit.repeat(setup=setup, stmt=extend_empty))
0.27297509999971226
>>> min(timeit.repeat(setup=setup, stmt=insert_empty))
0.49701270000059594

As expected, the most straightforward solution performs the best. Let’s see how that plays out as we grow our list:

>>> min(timeit.repeat(setup=setup, stmt=static_list_small))
0.1380927000000156
>>> min(timeit.repeat(setup=setup, stmt=slice_assignment_small))
0.5136848000001919
>>> min(timeit.repeat(setup=setup, stmt=append_small))
0.1721136000005572
>>> min(timeit.repeat(setup=setup, stmt=extend_small))
0.28814950000014505
>>> min(timeit.repeat(setup=setup, stmt=insert_small))
0.5033762000002753

Again, append() gets the job done the quickest. Now, let’s take a look at an enormous list:

>>> min(timeit.repeat(setup=setup, stmt=slice_assignment_large))
0.5083946000004289
>>> min(timeit.repeat(setup=setup, stmt=append_large))
0.18050170000060461
>>> min(timeit.repeat(setup=setup, stmt=extend_large))
0.28858020000006945
>>> min(timeit.repeat(setup=setup, stmt=insert_large))
0.5108225000003586

Amazingly, all these solutions seem to scale really well. That said, append() takes the cake. After all, it is amortized O(1). In other words, appending to a list is a constant time operation as long as we don’t run out of space.

That said, take these performance metrics with a grain of salt. After all, not every solution is going to be perfect for your needs.

Challenge

Now that we know how to add an item to a list, let’s try writing a simple sorting algorithm. After all, that’s the perfect task for someone who wants to get familiar with the various list manipulation methods.

Personally, I don’t care which sorting algorithm you implement (e.g. bubble, insertion, merge, etc.) or what type of data you choose to sort (e.g. numbers, strings, etc.). In fact, I don’t even care if you sort the data in place or create an entirely separate list. All I care about is that you use one or more of the methods described in this article to get it done.

When you think you have a good solution, feel free to share it in the comments. As always, I’ll share an example in the comments.

A Little Recap

With all that out of the way, let’s take a look at all our solutions again:

# Statically defined list
my_list = [2, 5, 6]

# Appending using slice assignment
my_list[len(my_list):] = [5] # [2, 5, 6, 5]

# Appending using append()
my_list.append(9) # [2, 5, 6, 5, 9]

# Appending using extend()
my_list.extend([-4]) # [2, 5, 6, 5, 9, -4]

# Appending using insert()
my_list.insert(len(my_list), 3) # [2, 5, 6, 5, 9, -4, 3]

By far, this has been one of my favorite articles to write in awhile. There’s nothing quite like learning something new while writing a short response to the question “How do I add an item to a list?”

If you liked this article, help me get it in front of more eyes by giving it a share. In addition, you can show your support by hopping on my mailing list, joining me on Patreon, or subscribing to my YouTube channel. Otherwise, check out some of these related articles:

Other than that, that’s all I’ve got! Thanks again for your support. See you next time!

The post How to Add an Item to a List in Python: Append, Slice Assignment, and More appeared first on The Renegade Coder.

How to Check if a String Contains a Substring in Python: In, Index, and More

Jeremy Grifski — Fri, 26 Jun 2020 18:00:01 +0000

One concept that threw me for a loop when I first picked up Python was checking if a string contains a substring. After all, in my first language, Java, the task involved calling a method like indexOf() or contains(). Luckily, Python has an even cleaner syntax, and we’ll cover that today.

To summarize, we can check if a string contains a substring using the in keyword. For example, "Hi" in "Hi, John" returns true. That said, there are several other ways to solve this problem including using methods like index() and find(). Check out the rest of the article for more details.

Problem Description

A common problem in programming is detecting if a string is a substring of another string. For example, we might have a list of addresses stored as strings, and we want to find all addresses on a certain street (e.g. Elm Street):

addresses = [
  "123 Elm Street", 
  "531 Oak Street", 
  "678 Maple Street"
]
street = "Elm Street"

In that case, we might check which addresses contain the street name (e.g. 123 Elm Street). How do we do something like this in Python?

In most programming languages, there’s usually some substring method. For instance, in Java, strings have an indexOf method which returns a positive number if the substring was found.

Even without a special method, most languages allow you to index strings like arrays. As a result, it’s possible to manually verify that a string contains a substring by looking for a match directly.

In the following section, we’ll take a look at several possible solutions in Python.

Solutions

As always, I like to share a few possible solutions to this problem. That said, if you want the best solution, I suggest jumping to the last solution.

Checking if String Contains Substring by Brute Force

Whenever I try to solve a problem like this, I like to think about the underlying structure of the problem. In this case, we have a string which is really a list of characters. As a result, what’s stopping us from iterating over those character to find our substring:

addresses = ["123 Elm Street", "531 Oak Street", "678 Maple Street"]
street = "Elm Street"
for address in addresses: 
  address_length = len(address) 
  street_length = len(street) 
  for index in range(address_length - street_length + 1): 
    substring = address[index:street_length + index] 
    if substring == street: 
      print(address)

Here, I’ve written a sort of nasty set of loops which iterate over all addresses, compute lengths of some strings, iterate over all substrings of the appropriate size, and prints the results if a proper substring is found.

Luckily, we don’t have to write our own solution to this. In fact, the entire inner loop is already implemented as a part of strings. In the next section, we’ll look at one of those methods.

Checking if String Contains Substring Using `index()`

If we want want to check if a string contains a substring in Python, we might try borrowing some code from a language like Java. As mentioned previously, we usually use the indexOf() method which returns an index of the substring. In Python, there’s a similar method called index():

addresses = ["123 Elm Street", "531 Oak Street", "678 Maple Street"]
street = "Elm Street"
for address in addresses: 
  try: 
    address.index(street) 
    print(address) 
  except ValueError: 
    pass

Here, we call the index function without storing the result. After all, we don’t actually care what the index is. If the method doesn’t find a matching substring, it’ll throw an exception. Naturally, we can catch that exception and move on. Otherwise, we print out the address.

While this solution gets the job done, there’s actually a slightly cleaner solution, and we’ll take a look at it in the next section.

Checking if String Contains Substring Using `find()`

Interestingly enough, Python has another method similar to index() which functions almost identically to indexOf() from Java. It’s called find(), and it allows us to simplify our code a little bit:

addresses = ["123 Elm Street", "531 Oak Street", "678 Maple Street"]
street = "Elm Street"
for address in addresses: 
  if address.find(street) > 0: 
    print(address)

Now, that’s a solution I can get behind. After all, it’s quite reminscent of a similar Java solution.

Again, it works like index(). However, instead of throwing an exception if the substring doesn’t exist, it returns -1. As a result, we can reduce our try/except block to a single if statement.

That said, Python has an even better solution which we’ll check out in the next section.

Checking if String Contains Substring Using `in` Keyword

One of the cool things about Python is how clean and readable the code can be. Naturally, this applies when checking if a string contains a substring. Instead of a fancy method, Python has the syntax built-in with the in keyword:

addresses = ["123 Elm Street", "531 Oak Street", "678 Maple Street"]
street = "Elm Street"
for address in addresses: 
  if street in address: 
    print(address)

Here, we use the in keyword twice: once to iterate over all the addresses in the address list and again to check if the address contains the street name. As you can see, the in keyword has two purposes:

To check if a value is present in a sequence like lists and strings
To iterate through a sequence

Of course, to someone coming from a language like Java, this can be a pretty annoying answer. After all, our intuition is to use a method here, so it takes some getting used to. That said, I really like how this reads. As we’ll see later, this is also the fastest solution.

Performance

With all these solutions ready to go, let’s take a look at how they compare. To start, we’ll need to set the solutions up in strings:

setup = """
addresses = ["123 Elm Street", "531 Oak Street", "678 Maple Street"]
street = "Elm Street"
"""

brute_force = """
for address in addresses: 
  address_length = len(address) 
  street_length = len(street) 
  for index in range(address_length - street_length + 1): 
    substring = address[index:street_length + index] 
    if substring == street: 
      pass # I don't want to print during testing
"""

index_of = """
for address in addresses: 
  try: 
    address.index(street) # Again, I don't actually want to print during testing 
  except ValueError: 
    pass
"""

find = """
for address in addresses: 
  if address.find(street) > 0: 
    pass # Likewise, nothing to see here
"""

in_keyword = """
for address in addresses: 
  if street in address: 
    pass # Same issue as above
"""

With these strings ready to go, we can begin testing:

>>>> import timeit
>>> min(timeit.repeat(setup=setup, stmt=brute_force))
4.427290499999998
>>> min(timeit.repeat(setup=setup, stmt=index_of))
1.293616
>>> min(timeit.repeat(setup=setup, stmt=find))
0.693925500000006
>>> min(timeit.repeat(setup=setup, stmt=in_keyword))
0.2180926999999997

Now, those are some convincing results! As it turns out, brute force is quite slow. In addition, it looks like the error handling of the index() solution isn’t much better. Luckily, find() exists to eliminate some of that overhead. That said, in is the fastest solution by far.

As is often the case in Python, you’ll get the best performance out of common idioms. In this case, don’t try to write your own substring method. Instead, use the built-in in keyword.

Challenge

Now that you know how to check if a string contains a substring, let’s talk about the challenge. We’re going to write a simple address search engine which filters on two keywords rather than one: street and number. However, we may not get both pieces of information at the time of search. As a result, we need to deal with finding addresses which exactly match whatever keywords are available.

For this challenge, you can write any solution you want as long as it prints out a list of addresses that exactly matches the search terms. For instance, take the following list of addresses:

addresses = ["123 Elm Street", "123 Oak Street", "678 Elm Street"]

If a user searches just “Elm Street”, then I would expect the solution to return “123 Elm Street” and “678 Elm Street”. Likewise, if a user searches “123”, then I would expect the solution to return “123 Elm Street” and “123 Oak Street”. However, if the user provides both “123” and “Elm Street”, I would expect the solution to only return “123 Elm Street”—not all three addresses.

Feel free to have fun with this. For example, you could choose to write an entire front end for collecting the street and number keywords, or you could assume both of those variables already exist.

In terms of input data, feel free to write your own list of addresses or use my simple example. Alternatively, you can use a website which generates random addresses.

Ultimately, the program needs to demonstrate filtering on two keywords. In other words, find a way to modify one of the solutions from this article to match the street, address, or both—depending on what is available at the time of execution.

In the comments below, I’ll share my solution. Feel free to do the same!

A Little Recap

And with that, we’re finished. As a final recap, here are all the solutions you saw today:

addresses = ["123 Elm Street", "531 Oak Street", "678 Maple Street"]
street = "Elm Street"

# Brute force (don't do this)
for address in addresses: 
  address_length = len(address) 
  street_length = len(street) 
  for index in range(address_length - street_length + 1): 
    substring = address[index:street_length + index] 
    if substring == street: 
      print(address)

# The index method
for address in addresses: 
  try: 
    address.index(street) 
    print(address) 
  except ValueError: 
    pass

# The find method
for address in addresses: 
  if address.find(street) > 0: 
    print(address)

# The in keyword (fastest/preferred)
for address in addresses: 
  if street in address: 
    print(address)

As always, if you liked this article, make sure to give it a share. If you’d like more articles like this to hit your inbox, hop on my mailing list. While you’re at it, consider joining me on Patreon.

If you’re interested in learning more Python tricks, check out some of these related articles:

Otherwise, that’s all I have. Thanks again for your support!

The post How to Check if a String Contains a Substring in Python: In, Index, and More appeared first on The Renegade Coder.

How to Perform a Reverse Dictionary Lookup in Python: Generator Expressions and More

Jeremy Grifski — Tue, 23 Jun 2020 15:34:22 +0000

Welcome to yet another Python tutorial. Today, we’re taking a look at dictionaries and how we can perform a reverse dictionary lookup. In words, how do we get a key from a dictionary given a value?

As it turns out, there are three main solutions. First, we could try explicitly looping over the dictionary using something like my_dict.items(). Alternatively, we could create a generator expression: next(key for key, value in my_dict.items() if value == value_to_find). Finally, we could invert the dictionary completely to retrieve the key like normal.

Problem Introduction

Awhile back, I wrote an article about how to invert a dictionary. In other words, how do we swap keys and values in a dictionary? Well, as it turns out, sometimes we don’t need to flip an entire dictionary. All we need is a key given a value.

Normally when we use a dictionary, we pass it a key to retrieve a value. But, what if we want to retrieve a key given a value? In other words, what if we want to perform a reverse dictionary lookup. For example, given the following dictionary, we might want to retrieve the first key that matches the value “red”:

my_dict = { 
  "color": "red", 
  "width": 17, 
  "height": 19
}

In this case, we would expect our solution to return “color”. Of course, there might be multiple keys that match. How do we decide which one to grab?

Luckily, we won’t be digging into the nuance in this article. Instead, we’ll be looking at a handful of solutions that return the first key or every key that matches the value.

Solutions

In this article, we’ll take a look at a few ways to perform a reverse ditionary lookup. As always, we’ll kick things off with a brute force solution. Then, we’ll look at some more sophisticated solutions.

Reverse Dictionary Lookup by Brute Force

Perhaps a straightforward way of solving this problem is to iterate over the dictionary until we find the value we’re looking for:

my_dict = {"color": "red", "width": 17, "height": 19}
value_to_find = "red"
for key, value in my_dict.items(): 
  if value == value_to_find: 
    print(f'{key}: {value}')

In this case, we’re searching the dictionary for the value “red”. During each iteration, we’ll check if the value we’re looking for matches the current value. If it does, we print the results.

If we copy this solution verbatim, it will actually spit out all the matching keys. In this case, we’ll only see “color: red”. That said, a larger dictionary could yield duplicates.

At any rate, there are plenty of more interesting solutions ahead!

Reverse Dictionary Lookup Using a Generator Expression

Instead of looping over our dictionary explicitly, we could leverage a generator expression (PEP 289) which looks a lot like a list comprehension:

my_dict = {"color": "red", "width": 17, "height": 19}
value_to_find = "red"
key = next(key for key, value in my_dict.items() if value == value_to_find)
print(f'{key}: {value_to_find}')

Naturally, the difference between a list comprehension and a generator expression is that there’s no list created. In other words, we save memory and possibly time.

In the example above, instead of generating a list of all of the key-value pairs and iterating over them, we repeatedly generate a new key-value pair until we find one that matches. This clever bit of code is basically a condensed version of our loop from our brute forced solution. Of course, the iteration stops when we find what we need.

Again, be aware that this solution will only return the first key that matches our lookup value. If we wanted more than one key, we’d have to store the generator expression:

exp = (key for key, value in my_dict.items() if value == value_to_find)
next(exp) # First matching key
next(exp) # Second matching key

If we call next more times than there are matches, we get a StopIteration error. As a workaround, we can use a for-each loop directly:

exp = (key for key, value in my_dict.items() if value == value_to_find)
for key in exp: 
  print(key)

Now, isn’t that nice?

Reverse Dictionary Lookup Using an Inverse Dictionary

As I mentioned in the problem description, we can always completely flip the dictionary:

my_dict = {"color": "red", "width": 17, "height": 19}
value_to_find = "red"
my_inverted_dict = {value: key for key, value in my_dict.items()}
key = my_inverted_dict[value_to_find]

If you haven’t had a chance to read the other article, basically this solution takes advantage of a dictionary comprehension. In other words, it constructs a new dictionary from the original dictionary. Naturally, the part that does the magic is value: key which reverses the mapping.

Unfortunately, this solution won’t work for every circumstance because not all values are hashable (e.g. lists), but it gets the job done. Likewise, it only saves the last key for any duplicate values. As a result, other possible keys are lost.

If we want a solution that generates a list of keys, we can do something like the following:

my_dict = {"color": "red", "width": 17, "height": 19}
value_to_find = "red"
my_inverted_dict = dict()
for key, value in my_dict.items(): 
  my_inverted_dict.setdefault(value, list()).append(key)
keys = my_inverted_dict[value_to_find]

In this example, we end up with a list of keys rather than a single key.

Performance

As always, let’s take a look at the performance of each of these solutions. First, we’ll need to set them up in strings:

setup = """
my_dict = {"color": "red", "width": 17, "height": 19}
value_to_find = "red"
"""

brute_force_single = """
for key, value in my_dict.items(): 
  if value == value_to_find: 
    break
"""

brute_force_multi = """
for key, value in my_dict.items(): 
  if value == value_to_find: 
    pass
"""

generator_single = """
next(key for key, value in my_dict.items() if value == value_to_find)
"""

generator_multi = """
exp = (key for key, value in my_dict.items() if value == value_to_find)
for key in exp:
  pass
"""

inverse_single = """
my_inverted_dict = {value: key for key, value in my_dict.items()}
my_inverted_dict[value_to_find]
"""

inverse_multi = """
my_inverted_dict = dict()
for key, value in my_dict.items(): 
  my_inverted_dict.setdefault(value, list()).append(key)
my_inverted_dict[value_to_find]
"""

For the sake of completeness, I adapted each solution to each possible scenario. Either we want a single key, or we want many keys. As a result, each test is labeled single or multi, respectively.

In terms of testing, here are the results:

>>> import timeit
>>> min(timeit.repeat(setup=setup, stmt=brute_force_single))
0.19409550000000309
>>> min(timeit.repeat(setup=setup, stmt=brute_force_multi))
0.3046430999997938
>>> min(timeit.repeat(setup=setup, stmt=generator_single))
0.6223289999998087
>>> min(timeit.repeat(setup=setup, stmt=generator_multi))
0.6531434000003173
>>> min(timeit.repeat(setup=setup, stmt=inverse_single))
0.5350638999998409
>>> min(timeit.repeat(setup=setup, stmt=inverse_multi))
1.2309030999999777

Weirdly enough, the generator expression solution is actually quite slow. Perhaps, there’s a bit of overhead with creating a generator expression. I was interested to see how this solution scales with larger dictionaries, so I updated the setup string and reran my tests:

>>> setup = """
my_dict = {"color": "red", "width": 17, "height": 19, "health": 15, 
"depth": 100, "direction": "north", "material": "metal", "power": 17, 
"strength": 17, "weight": 111, "x": 0, "y": 0, "z": 0, 
"song": "Madeline", "band": "The Wonder Years", 
"friend": "rupert"}
value_to_find = "red"
"""
>>> min(timeit.repeat(setup=setup, stmt=brute_force_single))
0.18737550000059855
>>> min(timeit.repeat(setup=setup, stmt=brute_force_multi))
0.9153716000000713
>>> min(timeit.repeat(setup=setup, stmt=generator_single))
0.5850626999999804
>>> min(timeit.repeat(setup=setup, stmt=generator_multi))
1.2661715000003824
>>> min(timeit.repeat(setup=setup, stmt=inverse_single))
1.4036990000004153
>>> min(timeit.repeat(setup=setup, stmt=inverse_multi))
5.085829500000727

Again, I was a bit bothered by the results, so I tried changing the value we were searching for:

>>> setup = """
my_dict = {"color": "red", "width": 17, "height": 19, 
"health": 15, "depth": 100, "direction": "north", 
"material": "metal", "power": 17, "strength": 17, 
"weight": 111, "x": 0, "y": 0, "z": 0, "song": 
"Madeline", "band": "The Wonder Years", 
"friend": "rupert"}
value_to_find = "The Wonder Years"
"""
>>> min(timeit.repeat(setup=setup, stmt=brute_force_single))
0.8808984999996028
>>> min(timeit.repeat(setup=setup, stmt=brute_force_multi))
0.9333926999997857
>>> min(timeit.repeat(setup=setup, stmt=generator_single))
1.303262800000084
>>> min(timeit.repeat(setup=setup, stmt=generator_multi))
1.295239500000207
>>> min(timeit.repeat(setup=setup, stmt=inverse_single))
1.3928389000002426
>>> min(timeit.repeat(setup=setup, stmt=inverse_multi))
5.030787800000326

Again, brute force has the best performance. When I looked into why, I found that there’s a bit of overhead as I suspected. If I had the time, I’d probably run each of this solutions through cProfiler as outlined in my performance article. That said, I’ll defer to the responses in this Stack Overflow thread.

Overall, it looks like each solution performs in the order they were presented. In other words, brute force is slightly faster than a generator expression. Meanwhile, flipping the dictionary can be extremely costly.

Challenge

With all the fun stuff out of the way, let’s take a look at your challenge. Since covering the reverse dictionary lookup, I thought it would be fun to challenge you with the following:

Look at all three solutions above (or 6 if you include the various requirements). Can you break down exactly why each solution performs the way it does? In other words, can you explain the differences in performance between each solution? Why would looping over a dictionary be faster than using a generator expression? Why wouldn’t flipping the dictionary be fastest?

As I alluded to previously, you can use any tools at your disposal to support your reasoning. For instance, you might try using cProfile to exam the inner workings of each solution. Likewise, you might try running various tests like I did with timeit. Perhaps a plot of each solution under different workloads would help you figure out asymptotic runtimes.

Maybe, you don’t want to run any empirical testing tools at all. Instead, you want to look directly at the source code and trace what work it has to do to accomplish our task. Whatever you choose to do, make sure you share your results on Twitter using the hashtag #RenegadePython!

In case you’re wondering, I kicked things off with a quick execution of cProfile.run() on our brute_force_single solution:

// Detect dark theme var iframe = document.getElementById('tweet-1251974523018260486-993'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1251974523018260486&theme=dark" }

I wonder what the other solutions look like under the hood!

A Little Recap

And with that, we’re done! Here’s all the solutions from this article in one place:

my_dict = {"color": "red", "width": 17, "height": 19}
value_to_find = "red"

# Brute force solution (fastest) -- single key
for key, value in my_dict.items(): 
  if value == value_to_find: 
    print(f'{key}: {value}') 
    break

# Brute force solution -- multiple keys
for key, value in my_dict.items(): 
  if value == value_to_find: 
    print(f'{key}: {value}')

# Generator expression -- single key
key = next(key for key, value in my_dict.items() if value == value_to_find)
print(f'{key}: {value_to_find}')

# Generator expression -- multiple keys
exp = (key for key, value in my_dict.items() if value == value_to_find)

for key in exp:
  print(f'{key}: {value}')

# Inverse dictionary solution -- single key
my_inverted_dict = {value: key for key, value in my_dict.items()}
print(f'{my_inverted_dict[value_to_find]}: {value_to_find}')

# Inverse dictionary solution (slowest) -- multiple keys
my_inverted_dict = dict()
for key, value in my_dict.items(): 
  my_inverted_dict.setdefault(value, list()).append(key)
print(f'{my_inverted_dict[value_to_find]}: {value_to_find}')

With all that out of the way, it’s time for me to ask you for a little help! Specifically, I’d love it if you hopped on my mailing list or even became a patron. In addition, I’m trying to grow my YouTube channel, so head on over and subscribe.

If you have the time, I’d appreciate it if you stuck around to check out some of these related articles:

Otherwise, thanks for stopping by! I appreciate it.

The post How to Perform a Reverse Dictionary Lookup in Python: Generator Expressions and More appeared first on The Renegade Coder.

DEV Community: Jeremy Grifski

Sample Programs Repo Celebrates 1,000 Code Snippets

Table of Contents

A Brief History of the Repo

1,000 Program Breakdown

Looking Ahead

Support The Sample Programs Repo This Hacktoberfest

What Is the Sample Programs Repository?

TheRenegadeCoder / sample-programs

Sample Programs in Every Programming Language

Sample Programs in Every Language

Learn More

Support

Who Is Eligible to Support the Sample Programs Repository?

What Kind of Work Can One Accomplish During Hacktoberfest?

How Do I Support the Sample Programs Community?

How to Get Better at Programming: Lessons from Blogging

Blogging Expertise

Lessons From Blogging

Pacing Is the Key To Progress

Interest Matters for Long Term Sustainability

Creativity Maximizes Outcomes

Readability Helps the Reader

What Else Can Programmers Borrow?

What Are Some Tech Questions You're Too Afraid to Ask?

How to Get Better at Programming: Lessons from Competitive Shooter Games

Competitive Shooter Expertise

Lessons From Competitive Shooter Games

Learn When to Take a Break

Make Your Gear Grow With You

Learn to Be a Team Player

Don’t Forget Your Objective

What Else Can Programmers Borrow?

How to Get Better at Programming: Lessons From Music

Music Expertise

Borrowing Practice Skills From Music

Transcription == Reverse Engineering

Transposition == Substitution

Sight Reading == Proof of Concept

What Else Can Programmers Borrow?

Can We Fit Rock Paper Scissors in Python in a Tweet?

Where Did We Leave Off?

Begin Compression

Iterable Unpacking

Rewriting Input String

Renaming the Import

Renaming All Variables

Removing Comments and Empty Lines

Eliminating Extraneous Spaces

Crushing Branches

Removing Redundant Brackets

Reducing Redundant Strings

Removing Function Calls

Converting Lists to Strings

Using Walrus Operators Everywhere

Taking Advantage of the Import

Revisiting String Manipulation

Reworking User Prompts

Lessons Learned

Does Anyone Still Code Golf? The 280 Character Challenge

The Sample Programs Repos Are Ready for Hacktoberfest 2020

What Is the Sample Programs Repo?

How Has the Sample Programs Repos Prepared for Hacktoberfest 2020?

How Can I Help Out?

Best of Luck!

How to Add an Item to a List in Python: Append, Slice Assignment, and More

Problem Description

Solutions

Add an Item to a List Statically

Add an Item to a List by Slice Assignment

Add an Item to a List with Append

Add an Item to a List with Extend

Add an Item to a List with Insert

Performance

Challenge

A Little Recap

How to Check if a String Contains a Substring in Python: In, Index, and More

Problem Description

Solutions

Checking if String Contains Substring by Brute Force

Checking if String Contains Substring Using `index()`

Checking if String Contains Substring Using `find()`

Checking if String Contains Substring Using `in` Keyword