Sherman On Software Latest

  • Why SaaS Projects With “New” Or “Next” In The Name Are Likely To Fail

    Why SaaS Projects With “New” Or “Next” In The Name Are Likely To Fail

    Replacing useful software is hard.  Naming things is hard.  Somehow naming projects to replace software seems easy.  

    If your system is called [X], the replacement project is called New [X] or Next Generation [X].

    These names aren’t “easy”, they are a sign that your project is poorly thought out and likely doomed.  This is especially true in SaaS where your customers are paying for this generation.

    New [X] is a sign that your project is inward looking and hasn’t considered your customer’s needs.  Do they need “New” or do they need specific features?

    New [X] invites scope creep: new idea + new [x] = features in new [x].  Does the new idea fit in with the purpose of New [X]?  Well, it’s new!

    New [X] turns up the pressure on the release.  It’s new!  We couldn’t ship the features to customers incrementally, we have to do a grand reveal and make a splash!

    A poorly considered project, with lots of scope creep, and the pressure of making a splash combine to doom New [X].

    It is completely fine to replace useful software with a better design and new technology.  Even if you do it iteratively, the end goal is a new version of the same system.  And it turns out that there is a simple naming system you can use!

    If your system is called [X], the next iteration of the system is called [X][int++].
    Your customers don’t care if you replace MySaaSBackend with MySaaSBackend2.  They shouldn’t even notice.

  • The Never Rewrite Podcast, Episode Seventy, Resource Engineering

    The Never Rewrite Podcast, Episode Seventy, Resource Engineering

    Isaac and Jeffrey delve into the concept of resource engineering, emphasizing the importance of understanding cost implications in engineering decisions. They discuss how engineers often overlook financial aspects while focusing on technical solutions, leading to potential inefficiencies. The dialogue highlights the need for engineers to have greater visibility into costs, particularly in cloud services like AWS, and how this awareness can drive better decision-making. They also explore the balance between optimizing costs and developing new features, advocating for a more business-oriented mindset among engineers to enhance overall effectiveness.

    Watch on YouTube or listen to it at NeverRewrite, Spotify, Apple Podcasts, or Amazon Music, and let us know if you have ever been involved in a rewrite. We would love to have you on the show to discuss your experience!

  • Are Foreign Keys Slower Than Corrupt Data Is Expensive?

    Are Foreign Keys Slower Than Corrupt Data Is Expensive?

    It sounds like a category error, but it’s a real trade off baked into every SaaS with a relational database.  This is the tradeoff behind the question “Should we use Foreign Keys in our database?”

    Many don’t, based on the argument that Foreign Keys slow down data insertion.  The database does extra checks when inserting, deleting, and updating data, which reduces throughput.  Foreign Keys force devs to check the database and require that insertions and deletions go in a specific order.  The database runs slower and development takes longer.

    On the other side of the tradeoff, Foreign Keys prevent entire categories of database issues.  They ensure that data is inserted and deleted in the correct order.  When something goes wrong, Foreign Keys prevent data corruption.  They are important, but optional, safety equipment.

    Back to the tradeoff: Are Foreign Keys going to raise your DB and developer costs more than you’ll lose from customer churn and developer time spent remediating data corruption?

  • The Never Rewrite Podcast, Episode Sixty-Nine, Anxiety When Fixing a System You Didn’t Create

    The Never Rewrite Podcast, Episode Sixty-Nine, Anxiety When Fixing a System You Didn’t Create

    Isaac and Jeffrey delve into the anxiety developers face when dealing with legacy systems they did not create. They explore the reasons behind the fear of fixing such systems, the challenges of refactoring, and the skills required to navigate these situations. The discussion emphasizes the importance of understanding legacy code, learning from it, and developing strategies to reduce anxiety when approaching refactoring tasks. Practical tips are provided for developers to build confidence and make meaningful contributions to legacy systems.

    Watch on YouTube or listen to it at NeverRewrite, Spotify, Apple Podcasts, or Amazon Music, and let us know if you have ever been involved in a rewrite. We would love to have you on the show to discuss your experience!

  • Dropdooms! How Binding an Unbounded Reference Table Can Kill Your UI’s Performance

    Dropdooms! How Binding an Unbounded Reference Table Can Kill Your UI’s Performance

    It’s a situation you never want to find yourself: Client support pulls you into a call with a large client, and they’re not happy. The website is slow! You need to fix it!

    You know that websites can almost always be more responsive, but it’s not bad enough to justify this level of frustration. You start to ask questions. Where do things get slow?  The “Add a New Deal” screen?  That’s a simple page, there’s nothing going on there.

    You go through the process of testing and pull it up on:

    • Your dev environment. You see a sub-second load time.
    • The test environment in production. There’s a sub-second load time there, too. 
    • The client’s account. The load time is only 45 seconds.

    How could that be? You wonder if the client’s database is overloaded. You check but the rest of their account is responsive.

    That’s when you spot it — the stage dropdown has 25,000 elements.

    You’ve been dropdoomed!

    What is a dropdoom?

    Here is an example of a 4 element dropdown that operates fine with no loading issues.

    A dropdoom is a regular DROPDOWN UI element that is populated from a user-generated list.  When the dropdown gets more than (roughly) 300 elements it will start impacting page rendering. And that’s when it switches from a dropdown to a dropdoom.

    Add 500 stages and the same screen now takes 3 seconds to load.

    The same screen now takes 3 seconds to load.

    Even on fast computers, dropdowns with more than a few hundred elements are going to slow down page rendering.  

    With the example covered above, the developers gave clients the ability to add custom deal stages. The assumption that the list would be short — how many stages can a deal have?  Apparently 25,000! The clients generated so much data that rendering the dropdown became a performance bottleneck. Since only the client could see their own data, the developer didn’t know that the issue existed until the client called to complain.

    Other examples of real dropdooms I’ve encountered include:

    • Assigning a task to an employee using a dropdown with all employees. This worked fine at first — until the company expanded to 2,000 employees. A combined total of 6 dropdooms added 20 seconds to the page rendering time. Using the task system became a chore, and eventually people stopped using it entirely.
    • A multi-select dropdown with all the tags a user has created. The page loaded in less than a second for clients with only a dozen tags. It became an issue when a client had 80,000 tags, increasing load time to over 30 seconds.
    • A survey with a dropdown to select your favorite European city. The dropdown showed a list of the largest 2,080 cities in Europe. That one element added 3 additional seconds to the survey’s load time.

    The underlying problem

    Most of the time fields will only have a handful of options. But some fields will always be growing, slowly at first, and then an exponential explosion. When things go bad, it isn’t the user’s fault for hiring too many employees, creating too many tags, or running a survey with too many cities.

    You’ve handed the user experience to the users, but kept control of the interface. And sometimes, clients will abuse a feature on accident – those 80,000 tags were a result of a developer developing against the API.

    The Solution

    Instead of a simple dropdown, the safest default option is a type-ahead search. This requires users to have some idea what to type in order to make results appear.

    Other options include:

    • The top 10 options plus a type-ahead option
    • An interstitial/pop-up with all the options in paginated results 
    • A mix of top options and an interstitial option

    There’s no magic solution, and it can be easy to blame the user.  Users will always do things you don’t expect and might not make sense to you — but they’re not developers, you are.  Making safe tools to protect the user from inadvertently impacting performance is your job. When you can think ahead and plan for possible outcomes, you can solve the problem before it even starts — and avoid a dreaded dropdoom. 

  • Could you do a cold restart?

    Could you do a cold restart?

    Years ago I worked at a mortgage company that bought a bank’s mortgage division.  The deal was mostly for sales people, but it also included custom software and developers.  To ensure that the handover was clean, we were only given the source code.

    We had DB Schemas, but no seed data.

    This was at the very dawn of Infrastructure-as-code; we didn’t get any.

    There were docs about deploying, and there were docs about building servers; they were wildly out of date.

    18 months and millions of dollars in salary and opportunity cost later, the project was shut down.  We never got the system fully functional.  We never got close.

    You probably won’t be sold to a competitor, but there’s a decent chance your production environment will get compromised by hackers.  

    If you lost all running instances of your software and had to rebuild from whatever you had in source control, could you do it?

    How long would it take?

  • The Never Rewrite Podcast, Episode Sixty-Eight, The Fallacy of Rewriting Software to Save Money

    The Never Rewrite Podcast, Episode Sixty-Eight, The Fallacy of Rewriting Software to Save Money

    Jeffrey and Isaac discuss the fallacy of rewriting software to save money. They highlight that organizations end up running multiple systems simultaneously, resulting in increased costs. The conversation also touches on the challenges of maintaining multiple versions of a software system and the importance of continuous delivery and iteration. It concludes by emphasizing the need to prove the ability to migrate existing pages before starting a rewrite.

    Watch on YouTube or listen to it at NeverRewrite, Spotify, Apple Podcasts, or Amazon Music, and let us know if you have ever been involved in a rewrite. We would love to have you on the show to discuss your experience!

  • The Never Rewrite Podcast, Episode Sixty-Seven, Revisiting “The Joel Test: 12 Steps to Better Code”

    The Never Rewrite Podcast, Episode Sixty-Seven, Revisiting “The Joel Test: 12 Steps to Better Code”

    We revisit The Joel Test, a 12-question test to determine if a software development team is set up for success. Jeffrey and Isaac discuss the relevance of each question in today’s context and how the industry has evolved over the years. The topics covered include source control, building and deployment processes, bug tracking, bug fixing, project scheduling, specifications, working conditions, and tools.

    Watch on YouTube or listen to it at NeverRewrite, Spotify, Apple Podcasts, or Amazon Music, and let us know if you have ever been involved in a rewrite. We would love to have you on the show to discuss your experience!

  • The Never Rewrite Podcast, Episode Sixty-Six, Squashing the Right Bugs

    The Never Rewrite Podcast, Episode Sixty-Six, Squashing the Right Bugs

    Isaac and Jeffrey discuss the importance of effective bug bashing and how to prioritize bug fixes. They highlight the need for categorizing bugs, understanding customer impact, and installing analytics to make informed decisions. They also emphasize the importance of writing tests and having a team member close to the customer to provide context. They recommend starting with backlog grooming and prioritization before diving into bug fixing. Overall, the conversation provides valuable insights for managers and developers dealing with bug backlogs.

    Watch on YouTube or listen to it at NeverRewrite, Spotify, Apple Podcasts, or Amazon Music, and let us know if you have ever been involved in a rewrite. We would love to have you on the show to discuss your experience!

  • 5 Tactics To Start Scaling Software

    5 Tactics To Start Scaling Software

    I can’t blindly tell you why your software is slow and won’t scale.  Everyone’s software and situation are different.  If you’re stuck with no idea where to begin, these are my top 5 tactics for getting started when you don’t know what to do.

    These tactics will improve the performance and stability of your system.  They will help you understand the system’s constraints and bottlenecks.  They probably won’t be the optimal solution to your problem, but they are a great place to start

    1. Fix the errors in the logs and stop logging things that don’t matter.  Not all errors are bugs, and not all bugs produce errors.  Noisy logs that are full of meaningless errors make it hard to see “real” problems.  Fixing or suppressing the noise will help you, learn the code, and fix a bunch of small problems.  Exceptions are also slow, so this will make the system faster and more stable
    2. Reduce the amount of db usage.  Add caching for data that gets requested and doesn’t change.  At scale even trivial queries add up. Ex: loading countries or states from a db. 
    3. Make work async – move it to queues.  This allows you to keep api/ui moving and sets you up for eventual parallelism. 
    4. Make work restartable/idempotent/recoverable.  Things break, make it easy to just try again 
    5. Shadow users.  Learn what they think is important and broken. It probably isn’t what you thought.