I got inspired to start trying to use Vim when I attended the Python national conference in Pittsburgh in 2025 and I met a hand full of old school coders who were among the fastest and most fluid that I have ever encountered. Watching them use their computers was like watching Yo-Yo Ma play the cello. Absolutely beautiful.

I was so inspired, in fact, I challenged myself to learn enough vim to be able to build the first version of my Pycleball web bot using a Vim extension in VS code. 

Vim is famous among its users because it makes it possible to not have to use your mouse. Essentially, everything is possible with keystrokes and shortcuts, which are called "motions".

Here are some reflections from the experience.  

First, if you want to get started with Vim give yourself an excuse while you browse the web with Vimium C, a keyboard shortcut browser extension. Vimium C makes it possible almost all the time to browse without touching your mouse. Because it's inspired by Vim, it gives you a perfect on ramp to start using some vim motions. For example...

• yy copies the url of the page that you're on and puts it into your clipboard
• J and K scroll up and down on the page
• F superimposes a letter or letter combination above every active link so that you can simply type in that combination and navigate to that link location
• shift + H navigates back to the previous page, shift + L navigates forward. 
• yv allows you to enter a mode where you can select specific text strings to copy them. 

Vimium C is a game changer and I'd never want to browse the web without it. It takes some getting used to but it's COMPLETELY worth the effort in my opinion - even if you don't plan to use Vim. If you spend any time at all on the internet ever, it's worth it. 

Second, the Vim extensions in VS Code are not fully functional and there are certain things that will just never be the same outside of Vim or an IDE like Neovim. The first shortcut I made once I installed Vim was a keyboard combination that allowed me to deactivate the plugin, and that was a great choice because certain things (like copy and paste) simply don't work like you'd expect when you start. It's also the case that you cannot repurpose any actual Vim configurations you've set up on your machine (as in your .vimrc file) with complete fidelity in VS code because the standard extension doesn't support a reference to your .vimrc file. Because I'd like to go deeper with Vim, I'm looking for ways to use it in a fully fledged IDE like Neovim next. 

Third, find a resource to keep practicing. I found a PDF version of "Practical Vim" by Drew Neil that I went through for about 20 minutes every day for three weeks or so to get my feet under me. It was slow but I was so inspired to learn Vim that the prospect of getting a bit better every day is still exciting. Do this while you actually incorporate the motions into your workflow. Expect to be slowed down - a lot. 

I'm still slow, but I saw for myself what it's like when you really get going with Vim. I'm still in the phase where I'm taking one step until I can take two steps forward, but using Vim also makes the whole process fun which doesn't make it all feel like work. 

I recently heard of a business analyst who trying to argue that “requirements gathering” and “solutioning” are two completely separate steps in the process of delivering software to clients.

I have encountered this idea before. I think this kind of thinking is a huge problem. This post explains why and offers an alternative, which is to think of “requirements gathering” and “solutioning” as steps in a larger process of principled negotiation.

What We Mean by “Requirements” and “Solutioning”

1.Requirements

As software development as an industry and practice was evolving in the late 20th century, the term the term “requirements” emerged as a way to refer to the set of things detailed in some kind of documentation about how a given system should function and what it should do when it is built. For example, if your daughter asks for a way to get to her best friend’s house 10 blocks away, the requirement might be to “have a means of transportation to get to Shirley’s house.” Great.

2.Solutioning

In my experience, “solutioning” generally refers to the process of determining what and how the requirements will be met. Returning to your daughter, this could take a huge number of forms, including a piggyback ride, a pogo stick, a pair of shoes, a skateboard, a hover craft, or a hot rod.

The origin of a “Requirements” vs. “Solutioning” Mindset

In my experience, the “Requirement” vs. “Solution” distinction happens most often when there is tension between client team / business interest (the commissioners/buyers) and the tech team (the builders/sellers). Basically, this distinction happens when the relationship is already strained. People start pointing fingers when they feel unheard or unseen and they turn litigious – focusing minutely on “what was requested” and “what was delivered” as a way to establish blame.

There is a reason that you hear the advice from married couples to “Not keep score.” It’s because keeping score is a loser’s game. Successful relationships are successful because needs of each party are met such that each feels better off than they were before.
Returning to the example with your daughter and her requirement for a transportation medium - suppose you have a crazy great uncle who just died and left you – surprise – a single Sheltland Pony. So you offer it to her because you don’t know what else to do with it. Do you just turn to your daughter and say “Well honey, strictly speaking your requirement was just that you needed a transportation medium, so really, I have met my obligation… so you’re welcome.”  Of course you don’t.

When people do draw this absurd line-in-the-sand, the obvious retort from the business interest is, similarly, to change the goal posts – e.g. “Well, the new requirement is that my transportation medium is a non-pony.”

This whole framing of the conversation gets no one anywhere. And intuitively, we all know this. In the real world, say, with your daughter, you ask your daughter to clarify what she needs and why she needs it and then you see what you can do and make work because you want to help.

An Alternative – Principled Solution Negotiation

Instead of quibbling this way about requirements and solutions, I think a better alternative happens in two general steps:

1. Frame the “requirements gathering” and “solutioning” as part of the same process, not distinct steps.  Do this by…
2. Treating the path to a solution as a principled negotiation, as spelled out in the classic book on negotiation: “Getting to Yes.” Principled negotiation has four parts:
   1. Separate the people from the problem.
   2. Focus on interests, not positions.
   3. Invent options for mutual gain.
   4. When necessary, focus on objective acceptance criteria

Basically, when you’re involved in a negotiation that is principled in this way, then you don’t let yourself get bogged down in a given position (i.e. “A pony is a transportation medium, isn’t it?!”) and instead, you focus on the interest and assumptions behind the request, that more often than not, result in a solution that actually works because it reflects true mutual understanding. 

PyCon 2025 in Pittsburgh was my first ever PyCon and it was a blast. My three big personal takeaways were the following:

1. The only constant is change
2. Let it be fun to build stuff
3. Knowing something and teaching it are different skills

The only constant is change
This year, some of the sexiest topics of the day seemed to be:

1. uv – the all-in-one python package manager
2. marimo notebooks (as a rising alternative to Jupyter notebooks)
3. Free threading / removing the global interpreter lock (and improving performance)
4. Lots of stuff about GPUs and Machine Learning

Of course, many, many, other themes were covered. But to me, the interesting part about this is that if you only went to PyCon before the last couple of years, you may not have heard nearly as much about any of these topics. My brother-in-law for example is a software engineer who uses Python at a super global tech company famous for cutting edge engineering teams – but since he’s moved into more of a management role, he hasn’t had the time to keep up with most of these latest developments. Every couple of months there is some new library, or API, or framework that seems to change the game, and it can be dizzying to try to keep up, so you have to remember to…

Let it be Fun To Build Stuff
The most fascinating and exhilarating two sessions that I went to were two self-organized sessions:

1. On Vim, the coding text editor known for speed.   
2. About dotfile configurations. Dotfiles are system configuration files that you can use to personalize, automate, and otherwise soup up the way you use your computer.  

I saw things in these sessions that made me feel like I had arrived at the promised land of programming. These folks made the simple act of writing code look like playing a beautiful piano concerto. Not one wasted movement. Pure passion for making the thoughts in your head result in behavior on the screen, like a ice skater doing a perfect 10 triple lutz. It was poetry. I’m not joking. It was so beautiful, I may never recover. After this, I made a determination to learn Vim. 
 
Knowing Something and Teaching It Are Different Skills
Given that two different Python programmers can be in radically different areas of the Python universe, it can be as hard for them to communicate with each other as it could be for two different aliens from different planets.

I went to many sessions that were completely over my head technically. And, looking around, I could see that I wasn’t alone. It makes sense that for many people, PyCon is the one chance that they have a year to talk with the 7 other people who are experts at their thing - it’s no surprise that they use their time to address that audience instead of a newbie.
This was one of the big reasons why I especially loved Al Sweigart’s, talk on “Making Python Talk, Making Python Listen.” The talk was super fun and accessible. Al is a Python educator, so he thinks a lot about how to communicate technical ideas and is very good at it.

A close friend of my brother's was recently diagnosed with cancer. After my brother found out, he called me and asked if I could help him think of a way that his friend (who we'll call "Anna") and my brother ("Zack") could listen to Bruce Springsteen songs together while Anna was going to chemotherapy treatments as a way to stay in touch and to give Anna something to stay busy with during her emotional roller coaster that is chemo treatment. 

I'm a business analyst - so I asked my brother about 2 hours worth of questions to try to see what he was envisioning and to understand how he expected the whole thing to work. 

These were the "functional requirements" that we landed on (this is much less formal than I'd usually prepare professionally, but this gives you the jist). 

The app:

1. Shows both Zack and Anna the same song every day in sequential order from Bruce Springsteen's latest album - a three set discography called "Tracks". On any given day, the song is referred to as "the assignment" or the "assigned song". 
2. The assigned song changes every day whether or not the given user has listened to it or not. 
   
3. Any assigned songs that were not listened to on their given day get put into a queue of "old assignments" that the user can see. This way, if Zach/Anna are behind, they can see exactly the songs that they need to listen to to get "caught up". 
4. Both Zack and Anna can leave their own reflections as or after they listen to the song in a text field 
5. All reflections are stored in a table that shows every song, both past and future. 
6. Each song is included with it's Spotify link so that the user can access a recording and listen to it quickly. 

This was an incredibly heartwarming thing to work on. It was really beautiful to see Anna and Zack's reflections on any given song be especially in the light of everything that she has been through and the importance that music has played in her journey. I also built it in such a way that my brother could see how far Anna had fallen behind, which gave him some insight into Anna's mental state so that he could offer some extra support when she may have needed it. 

And Knack made it relatively easy to build an app like this. If you have some basic facility with structured data (that is, normalized database structure), I highly recommend it. 

They make the point that the building construction metaphor is more palatable for business stakeholders because of the emphasis on structure, reliability, and predictability. However, they note that, in practice, software development is much more like gardening because of how constantly a team needs to be able to observe, manage, and respond to changing conditions. 

A critique of the construction metaphor:

1. In my experience, the most useful part of the construction metaphor is about the plumbing. Most people who live in houses don't understand how plumbing works, and they never want to have to think about it. It is clearly a specialized skill, and it helps frame the importance of getting something right because you don't want your toilet to back up, when, say, your extended family is visiting for Christmas. Business partners are also happy to not ask questions about plumbing because it's dirty and we all know it needs to get done. 
2. The construction metaphor can be souped up by comparing the development process to the building of a skyscraper or hospital, for example (hospital is my preference). Clearly, these require specialized expertise and, in the case of a hospital, are also clearly occupied by specialists themselves who have and require expensive equipment and facilities (surgical rooms, HVAC systems, large passageways for accessibility compliance). However, in my experience, the hospital construction analogy doesn't resonate with the experience or imagination of most business stakeholders. Why exactly, might be a subject for another post. 

A critique of the gardening metaphor: 
A garden metaphor is less useful if you are building something that you want to operate at scale, with, say, millions of users.  Etymologically, a garden refers to an "enclosure" and my experience suggests that that most people conceive of a garden as small and most often managed by a small number of relatively low-wage workers.

Three Alternative Metaphors
Considering the points above, it's natural to consider alternatives that emphasize the complexity, specialization, and scale requirements necessary to build a modern software application that adds business value. Here are my three favorites:

I started using the highway construction analogy after listening to a fascinating podcast about the "Big Dig" - which was, at the time, the most expensive highway project in U.S. history. This one is good for a very not romantic but extremely necessary of software development - gathering stakeholder buy in. Obviously, this is most useful in contexts where everyone knows that the project is useful but where political will needs to be mobilized (probably because it's not very sexy). 

I started using the founding a modern nation state when I was in a situation where I needed to emphasize an effort to different modules of the same website into a "federation" in which these separate entities submitted to a new set of administrative standards (In the analogy, the different modules were like different colonies that had their own cultures but now needed to come together just like the original American colonies needed to in order to form the United States). This is useful because it can inspire a revolutionary feeling to team members who need a way to understand why administration is important. If you want to emphasize the less sexy parts of software development, you can talk about the extensive bureaucratic functions of a modern nation state (post office, central bank, customs, trade negotiations, judicial systems for governance). The benefit of this analogy is that most people don't understand that the modern full-stack developer has to worry about all of these things. Often, I find, subject matter experts don't know, for example, how much time a developer needs to devote to making sure that that feature doesn't expose a security risk (customs), or establishing standards for how different pieces of an application communicate with one another (e.g. postal service if you want to emphasize the system, central bank if you want to emphasize the value of the information being transmitted).  

I started using the space mission analogy when there was some discord in one of my project teams and wanted to both respect the professionalism of members of the team and politely reframe the issue as being larger than ourselves. The Challenger Disaster analogy that this affords is useful if you need to remind people of stakes of failure. Finally, this analogy inspires the imagination in a way that others don't - there is something inherently interesting about "the final frontier" of space where - unlike the garden - there are clearly new horizons to explore and develop. 

The function produces an array (from a #SPILL formula) that includes a couple of useful elements:

• headers for clarity
• a "Distinct" column that shows all of the unique (non-duplicated) values 
• two columns with Boolean values (1 or 0) indicating whether or not the unique item is in the given list
• a "Category" column that codes the given item into one of 3 categories. Generically: 
  • 1. List 1 Only
  • 2. List 2 Only
  • 3. Both Lists

This way, you can easily target the discrepancies between the two lists (the Category 1s and 2s) or the commonalities (Category 3). 

If you just want to use this Lambda, here's the code you can copy and paste into the "Refers To" field in your name manager: 

Special thanks to Excel MVP Owen Price at Flex Your Data for the inspiration and base method for this formula from his Simple Frequency Table (Owen is an Excel MVP and it's obvious why because his posts are awesome).

I have given more descriptive names to my LET variables (e.g. what Owen calls "X" I call "list1LogicalMatrix"), but his matrix multiplication method is the core feature - otherwise I am simply rearranging the data produced by it. For a great explanation of how this works, I recommend visiting Owen's Simple Frequency Table post. 

Good luck! Happy to hear feedback / comments! 

How can restaurants make use of data science and geographic data to identify expansion opportunities? This analysis is an exploratory step in this direction. 

With Python, we can leverage Foursquare’s location data to help identify possible new opportunities for restaurants in specific geographic areas. We can help answer questions like:

• Is there already saturation in a given neighborhood or for a specific type of food?
• What kinds of establishments are already popular in a certain neighborhood?
• What kinds of geographic locations could be ripe for new development?

This small project will use geographic data for the city of Boston to identify food establishments of a particular type (in this case, Pizza Places) to determine whether certain neighborhoods may already be showing some saturation already. In addition, we will use this same information to understand if the existing neighborhood locations serve as sufficient categories for which to group these pizza places. Are all pizza places in the Financial District the same, or is there more variation between neighborhoods than within neighborhoods geographically?

In this project will also be downloading and accessing data from Foursquare. Foursquare is a company that provides location data and intelligence to its customers - primarily web developers - for use in their applications. In this project, we will be making a limited number of calls to Foursquare’s API to pull data about pizza places in areas of the city of particular interest.  We will be using the Foursquare [explore endpoint]( https://developer.foursquare.com/docs/places-api/endpoints/) to get venue recommendations in the “Pizza Place” Category.

As you can see from the maps above, even though 12 clusters were specified in the kmeans algorithm, these 12 clusters do NOT correspond to the same neighborhoods as mapped initially in this project. While the downtown core consists of 4 major neighborhoods (North End, West End, Downtown, Beacon Hill) there are 4 clusters that do not correspond to these neighborhood boundaries. Cluster 10 transverses both the North End and Downtown, Cluster 3 transverses the West End and the North End, Cluster 0 transverses Chinatown and Downtown, and Cluster 2 transverses Downtown and the South Boston Waterfront (Seaport).

One large takeaway from this analysis is that the South Boston Waterfront (Otherwise known as the Seaport District) has a dearth of pizza restaurants in general. Although this section of the city has been under extensive development recently, there is a paucity of pizza restaurants in this section of the city. Anyone who desired pizza who happened to be in this area would have to cross the fort point channel to get downtown.

Another key takeaway is that the neighborhoods are not a particularly useful starting place from which to begin our analysis. In order to get a fuller picture of the most operative development opportunities for Pizza Restaurants around the city, more research would be necessary to understand zoning restrictions and also the general socioeconomic status of any development area in question. Like McDonald’s, a pizza chain might fit best along highly trafficked areas of sprawling suburban areas.