I would like to start off by discussing some of the key factors involved in consistently keeping tech tools running smoothly. Some of these factors include clean code, a streamlined workflow, constant testing, and good communication with various teams. As a back-end engineer, my main focus is to make sure new features get done on time, work as expected without any issues, and don’t have a negative impact on any existing tools or features.
The absolute starting point in ensuring that code is easily maintainable and difficult to break is a clean code base and well-documented functionality. Every piece of the puzzle should be in its own place, separate from any unrelated elements. For instance, if you have one code block for dealing with inventory — that block should be separate from any code dealing with transactions. Organizing a code base in this way ensures, for this instance, that modifying inventory code will have a minimal impact on any transactional processes. Not only does this prevent unintended consequences, but it also makes it easier to find the exact piece of code for the component that needs work.
The next critical factor in my list is a sharp focus on testing. At every step in the development process, before there is a chance for anything to become infested with bugs — the key to preventing disasters is a solid testing procedure. Every key aspect of every component needs to have an automatable test ready to go. These tests are your friends; They are there to run through every piece of functionality and confirm that it does in fact perform as expected. For each new addition, no matter how small a new piece of functionality — all of the tests should be re-run, to double and triple check that nothing broke in the process. No new feature should be “merged in” to a code base without running this set of tests. Extensive testing confirms that no new bugs are introduced, and eliminates stress on all sides of the equation. Additionally, and possibly best of all — once the tests are written, it only takes one small command to run them all.
Speaking of keeping code working optimally — one of my favorite tools in the box is performance optimization. There are many different flavors of this fine beverage, and during the life cycle of a product, one must not hesitate to try them all. One of the many optimization methods available (one that I find very useful) — is called “profiling.” This is a method in which a code base is thoroughly analyzed by a background process to find indicators of any possible bottlenecks — such as “what takes the longest to run,” “what processes take up the most memory or processing power” or “why is this function being called so many times and is it necessary.” Running a profiler on your code base will tell you exactly where your code is clogging up your system’s arteries, and show you a full chain of events leading up to each clog. Pinning down the source of each piece of digital plaque, and implementing preventative measures will dramatically speed up your code base, making both end users and internal representatives happier.
Another key optimization tool in our magical optimization toolbox is something called “Load Balancing.” Similar to the architectural definition of the term, this is a means of taking the full weight of an object (in our case — massive amounts of simultaneous user traffic and database queries), and distributing it evenly amongst several load bearing “beams” or “cables” (in our case, servers and database instances). This is done with a special server that directs web traffic to the appropriate host for processing. Typically, a high traffic website will have several host servers for handling all of the incoming requests. When well configured, a load balancer can assure that the processing needs are equally distributed between all of the servers. It is also a common practice to use one or more servers for background processing, while sending them less or no web traffic. Database sharding utilizes a very similar approach, involving replica database servers, with different servers configured for different operations. Load balancing is one of the more complicated optimization methods, but being able to properly distribute the flow of traffic significantly improves page load times and prevents servers from crashing.
Just as important as any of the aforementioned, teamwork and communication are paramount in this process. Everyone’s input is valuable, and the more feedback you have to work with, the more improvements you can make, and the more potential issues you can prevent. As they say: “There is no I in team;” and in the world of tech projects — this saying holds true. It is important for a team to be able to communicate effectively, without much need for interpretation. Every successful team needs an agreed upon set of guidelines and standards, and should use the same language. In a proper team, one man’s “what’cha-ma-call-it” can’t be another man’s “you know, the green thing with the wheels.” Without consistency, lines of communication break down and frustration builds. Using common terms, and following the same guidelines leads to smooth, consistent progress with peace and tranquility.
To sum things up, i would like to note that the arsenal at the disposal of web professionals is ever-changing and growing larger with every subsequent year. The key to staying on top of what works, and what is soon to be left in the dust — is to constantly stay informed. Read the latest articles from trusted industry publications, go to trade shows and conferences — and keep an open mind. Change may be difficult sometimes, but it is often necessary; as hackers grow ever more sophisticated, so do the means for protection against them. Consistently making optimizations, performing upgrades, and expanding your arsenal, will keep you afloat above the water and let you sail smoothly into the future.
Nikita Nikitin
Back-End Engineer
Blue Bite
