Join Our Newsletter

Episode 12 - Unleashing Web Traffic with Content Delivery Networks

13 mins

Every website and application often delivers a number of assets as static content. Things like images, CSS or JavaScript, grow in number and total size as your site evolves. And along with them, you’ll also see a jump in load times and bandwidth requirements.

Site performance is an important part of improving your search rankings, discoverability, and traffic. Especially when so much of the web is now viewed through mobile devices with limited bandwidth or high latency.

Content Deliver Networks or CDNs, work by caching static assets across servers geographically distributed all over the world. They reduce load times, improve performance, and minimize bandwidth and infrastructure costs.

Let’s dive into the details.

Continue reading

Episode 10 - Studies in Search Engine Optimization And Why Developers Should Care (Part 1 of 2)

33 mins
2020-05-02 engineering seo

Most developers are aware of the term “Search Engine Optimization”, and like me, have a vague understanding of what it actually means. For a long time I thought that this was more about the content of a website than how that site was created or built. In other words, I saw it as an issue for the folks over in the marketing or sales organizations, certainly not for us engineers to worry about.

It turns out that the design and architecture of the technologies implementing a website have a large impact in it’s discoverability. I didn’t understand this until about a year or two ago when I needed to perform some optimizations for tryexceptpass.

I met up with Michael Kennedy from the Talk Python To Me podcast, and together we recorded our musings about SEO and present them to you in this two-part series.

Continue reading

Episode 9 - The Fascinating World of Intellectual Property Law and How it Applies to Software

12 mins
  • Intellectual Property Law was created to foster innovation and competition.
  • The concept has actually been around for centuries.
  • Today, IP Law provides a way to protect coding innovations that may be novel or unique.
  • It refers to ownership of intangible things, giving people and businesses property rights to the intellectual goods and innovation they create, usually for a limited time.

  • You can own a specific brand logo, a unique way of solving a software problem or even a composition.

  • There are four types of intellectual property:

    • Copyrights - for anything dubbed as “art” like paintings, music, etc.
    • Patents - for inventions, meant to purposely enable a monopoly on their production.
    • Trademarks - these are brand-related like logos, catchphrases and others that help identify a company.
    • Trade Secrets - concepts that give a business some competitive edge over another.
Continue reading

Episode 8 - Microservices Cheat-Sheet: Answers to 8 Common Questions

13 mins
2020-04-20 engineering

The majority of enterprises are either running in a microservices environment or studying how to do so. The concept has been around for a while, but used a lot like an industry term that means different things to different people. We’ll try to define the concept and some of the terminology used along with it.

Continue reading

Episode 7 - Basic Practices to Secure Your Application Architecture

13 mins
2020-04-13 engineering

Markets seem to reward fast product launches over secure one. This means that most organizations are not prioritizing security tasks early on. But following basic security practices early can yield great benefits without a significant increase in development time.

Continue reading

Episode 5 - Supercharge Your Coding Skills By Learning Software Architecture

14 mins
2020-03-09 engineering

Becoming a professional software developer is more than just getting better at a particular language, or learning more algorithms. You must learn about the development process itself, about design and architecture of a product. Following are a few things to consider/

  • Make sure your code is the correct code for the project as a whole.
    • Does it help you achieve the larger goals?
    • Does it impede future development or constrain possible future goals in any way?
    • Can you adjust constraints in a way that adds more value to the product?
    • What are the documentation implications of writing it a particular way?
    • Is it easy for someone else to pickup where you left off?
    • How should I break down the tasks into small ones such that there’s time to test things out and increase confidence on the new changes?
Continue reading

Episode 4 - 7 Practices for High Quality Maintainable Code

13 mins
2020-02-24 engineering testing
  • Code is complicated, hard to test, difficult to understand and can frustrate others.
  • Writing cleaner code can save you from reimplementing software simply that you cannot understand.
  • It’s an iterative process and there’s several principles to help you do that.
  • Keep it Simple Stupid (KISS) tells us to avoid unnecessary complexity and reduce moving parts. The idea is to write for maintainability.
  • Don’t Repeat Yourself (DRY) is about avoiding redundant implementations of the same function. You should think about refactoring.
  • You Aren’t Gonna Need It (YAGNI), an Extreme Programming principle, says we should stick with the requirements and avoid adding unneeded features or functions.
  • Composition over Inheritance asks us to take care when applying classes an inheritance in your design because it can lead to inflexible code.
  • Favoring Readability reminds us that writing software is like writing prose. Organize your code as if you’re writing a novel.
  • Practice Consistency tells us to stick with our decisions throughout the project. Keep the same format, implementation flow and design principles.
  • Consider How to Test a solution before writing it, or at least while writing. It helps you avoid traps that can unnecessarily complicate the code base.
Continue reading

Episode 3 - Decoupling Database Migrations at Application Startup

13 mins
  • Data models change and evolve with your application.
  • There’s plenty of tools that keep track of database schemas and automatically generate scripts to upgrade or downgrade them.
  • It’s common for developers to run a migration at the start of their app before running app code.
  • Our author explains two common problems with this approach.
    1. Modern day production deployments and horizontal scaling can get you into a race condition.
    2. You start assuming that new code will only ever run with the new schema.
  • You can decouple migrations from code changes by disabling parallelism during this time.
  • Make it a separate command or lock the database during the upgrade.
  • We can easily implement locking ourselves in any language.
    • Use Redis locks if you’re ok with something external to the DB.
    • Use the DB itself by writing to an extra table to say that you’re upgrading it.
  • Plan your deployment appropriately so you can run old code with new by making migrations additive in the short term.
  • Using a script at startup that optionally performs the migration based on an environment variable integrates wel with Docker and cloud services.
  • Upgrades of both code and data should be part of your testing BEFORE releasing to production.
Continue reading

Practical Log Viewers with Sanic and Elasticsearch - Designing CI/CD Systems

One of the critical pieces in a build system is the ability to view build and test output. Not only does it track progress as the build transitions through the various phases, it’s also an instrument for debugging.

This chapter in the continuous builds series covers how to build a simple log viewer. You’ll find details on retrieving log entries from Docker containers, serving them through Python, linking from a GitHub pull request, and highlighting the data for easy reading.

Continue reading

Painless Status Reporting in GitHub Pull Requests - Designing CI/CD Systems

Continuing the build service discussion from the Designing CI/CD Systems series, we’re now at a good point to look at reporting status as code passes through the system.

At the very minimum, you want to communicate build results to our users, but it’s worth examining other steps in the process that also provide useful information.

The code for reporting status isn’t a major feat. However, using it to enforce build workflows can get complicated when implemented from scratch.

Continue reading

Command Execution Tricks with Subprocess - Designing CI/CD Systems

The most crucial step in any continuous integration process is the one that executes build instructions and tests their output. There’s an infinite number of ways to implement this step ranging from a simple shell script to a complex task system.

Keeping with the principles of simplicity and practicality, today we’ll look at continuing the series on Designing CI/CD Systems with our implementation of the execution script.

Continue reading

Conveying Build and Test Information with Repository Badges

When you check out a repository on github, sometimes theres a little bit of flare at the top of the project that catches your eye. This bit of flare is called a badge and can be used to indicate build status, test coverage, documentation generation status, version support, software compatibilty statements or even community links to gitter or discord where you can find more help with the project. I used to think that badges were fancy fluff people added to their projects to make them seem more professional. Continue reading

Easy Clustering with Docker Swarm - Designing CI/CD Systems

Building code is sometimes as simple as executing a script. But a full-featured build system requires a lot more supporting infrastructure to handle multiple build requests at the same time, manage compute resources, distribute artifacts, etc. After our last chapter discussing build events, this next iteration in the CI/CD design series covers how to spin-up a container inside Docker Swarm to run a build and test it. What is Docker Swarm When running the Docker engine in Swarm mode your effectively creating a cluster. Continue reading

Awesome Webhook Handling with Sanic - Designing CI/CD Systems

After covering how to design a build pipeline and define build directives in the continuous builds series, it’s time to look at handling events from a code repository.

As internet standards evolved over the years, the HTTP protocol has become more prevalent. It’s easier to route, simpler to implement and even more reliable. This ubiquity makes it easier for applications that traverse or live on the public internet to communicate with each other. As a result of this, the idea of webhooks came to be as an “event-over-http” mechanism.

With GitHub as the repository management platform, we have the advantage of using their webhook system to communicate user actions over the internet and into our build pipeline.

Continue reading

Effortless Parsing of Build Specifications - Designing CI/CD Systems

Every code repository is different. The execution environment, the framework, the deliverables, or even the linters, all need some sort of customization. Creating a flexible build system requires a mechanism that specifies the steps to follow at different stages of a pipeline.

As the next chapter in the Comprehensive CI/CD Pipeline and System Design series, this article examines which instructions you’ll want to convey to your custom system and how to parse them. The focus is around a common solution, adding a file into the repository’s root directory that’s read by your execution engine when receiving new webhooks.

Continue reading

Best Tips for Running Enterprise CI/CD in the Cloud

There are many solutions to building code, some of them are available as cloud services, others run on your own infrastructure, on private clouds or all of the above. They make it easy to create custom pipelines, as well as simple testing and packaging solutions. Some even offer open source feature-limited “community editions” to download and run on-premises for free.

Following is my experience on the important aspects to consider when deciding on a build system for your organization that depends on cloud services. The original intent was to include a detailed review of various online solutions, but I decided to leave that for another time. Instead, I’m speaking more from an enterprise viewpoint, which is closer to reality in a large organization than the usual how-to’s. We’re here to discuss the implications and the practicality of doing so.

Continue reading
Older posts
© Copyright 2020 - tryexceptpass, llc