Is technical debt a recurring problem you face, or is trying to future proof the software you write the best course of action? Today, we take a look at one of the most complex problems when creating software, analyzing the pros and cons of both approaches.
by Scio Team
Software development is… complex. At its core, it’s an interesting challenge where improvement and evolution happen alongside the construction of the software itself, with the possibility that it changes course when you learn new things, get a new perspective, or bring diverse points of view to the table.
As we said elsewhere, developing software is very similar to writing a novel, or painting a picture: it’s as much of a discipline as is a creative exercise, borrowing and modifying itself throughout the project. However, there’s a big difference between a book and software; the software is part of an infrastructure, meant to interact with a user, across an undefined period, which gives this profession a unique challenge: what happens to the code I’m writing today when tomorrow arrives?
A debt to ourselves
“It’s OK to borrow against the future, as long as you pay it off”, are the words of Ward Cunningham, one of the authors of the Agile Manifesto, which revolutionized the way we look at software development. We all know how borrowing money works in our daily life, but what he referred to is a specific concept many in the software industry are aware of: Technical Debt.
As you may know, technical debt is “the implied cost of future refactoring or rework to improve the quality of an asset to make it easy to maintain and extend”; is the knowledge that certain parts of a program may require to be fixed at some point in the future.
There are plenty of reasons why a dev team may incur this “debt” (be it for budgeting, skill, or deadline reasons), but the nature of its payment is stumbling onto issues that need to be fixed quickly, which may bring more issues later that will require further fixes and so on, effectively like trying to pay a loan with a high-interest rate. If you are not careful, you will end up paying it perpetually.
Technical Debt is considered a serious problem and plenty of literature and management advice have been written to mitigate its effects, but like with any kind of loan, it can bring plenty of benefits if chosen and managed correctly. After all, if we take on a debt, it is for something in exchange, be it having cash on hand to accomplish something, or achieving working software to solve the issue at hand.
And the proper way to deal with debt, be it technical or otherwise, is to pay it on time, which in software development means refactoring a lot of the work done.
However, depending on the level of debt accrued by a team, this refactoring may bring a hefty tag, especially if the time between creating the program and improving it allowed many dependencies to flourish, or some of the knowledge behind the construction to get lost (such as the original team changing), so you may want to avoid the need of refactoring as much as possible because you don’t know the context in which the program will be improved. So what then?
A proof of thinking ahead
Futureproofing may be the answer. What futureproofing tries to do is “anticipate and minimize the effects of shocks and stresses due to future events.” This practice is not limited to software, but it can help to try and mitigate some of the problems technical debt will bring, especially if we are thinking ahead of the need for refactoring at a certain point in the future or having to deal with legacy software inside critical systems in any organization.
However, saying it is much easier than doing it, and any approach to futureproofing a system, so it can be tinkered with or without issue decades from now, is a tenuous art at best. After all, how can anyone predict what software will look like in 2050? The solutions we implement may make sense today, but will probably need some explanations later.
A solution could be, to create software that follows a pattern, so its logic can be easily deduced by a future dev team, as well as taking the proper due diligence when choosing tools and frameworks that have a better chance to remain supported or at least accessible in the coming years, or avoiding “monoliths” where a single application is responsible for tons of functions, but one can still get blindsided by a development impossible to foresee.
This brings an interesting conundrum for many developers trying to find the right approach: is it better to futureproof software to try and avoid technical debt, or is better to acquire some debt if that means having the flexibility to refactor software at some point in the next few years?
Two sides of the same coin
The reason is very simple, yet has lots of implications: if you acquire technical debt, you cannot futureproof because you are assuming you will need to change things. If you futureproof it, then you are making stuff that will greatly resist refactoring, making it likely to turn into “legacy” software.
A good approach to finding a solution to this is developing products with a few things in mind, mainly no software product is forever, and everything has a shelf life that we will need to wrestle with at some point.
“Generally, it is not until something breaks when a team realizes they have a big debt needing to be paid”, commented Scio’s PMO, Adolfo Cruz, about this issue. “It’s more common when a product is brand new and it’s still building its user base. The volume of transactions is low at first, so you may not see any problems, but if the scalability wasn’t planned well, then it’s more likely that debt will flow under the radar until it’s too late, so it’s important to take steps to prevent this.”
The trick is trying to push back that point as much as possible, having the proper procedures to ensure the code can be fixed. A good commenting discipline, for example, can save a lot of headaches while refactoring an application, letting whoever has to modify it knows what can break and what depends on every function. This can work as futureproofing without going into a lot of technical debt, as many of the problems when trying to refactor old programs is the fact that the code sometimes is not very clear, and in places of a lot of personnel turnover (like a government agency), it’s easy to let cracks grow.
The useful approach, then, is considering both of these concepts as the two sides of the same coin: the delicate balance that is developing good software amidst the needs of the now and the later. A great software development team should strive for products that pass the test of time, while also knowing that nothing is perfect, and using the need for refactoring as a tool, not only a problem.
What do you consider is the best approach when creating software? An application with some debt that will let you fix it in the future if it needs to, or building something hard to repair that may stand the test of time?
The idea of a future when AI can perform all sorts of tasks, even programming, is irresistible, but is it something feasible? Is programming a job that can be done by machines, and if not, why?
By Scio Team
One of the biggest leaps of these past two decades, and indeed the most intriguing technology development of the 21st Century, is the advancement of Artificial Intelligence that seems to occur every day. It is understandable why; science fiction technology has a sort of magnetism that attracts all kinds of engineers, entrepreneurs, and visionaries, many of them with the cash to back up the R&D necessary to bring these visions to life.
AI also has the allure of being potentially implemented anywhere, automatizing plenty of daily tasks to free up our time. It’s also attractively dangerous, as countless Terminator jokes can attest every time a new development hits the news.
However, what is actually feasible for AI to accomplish? What are its real applications, at least for now? For the last 7 years or so, there have been some talks about AI being capable of performing more intensive labor, programming, and development among them, but is the job of the programmer in danger of being done by a robot?
It’s easy to imagine, at least. Plenty of tools already use some measure of AI to function, and interesting experiments crop up daily, from intelligent chatbots to autonomous machines. But are those tasks comparable to the actual job of programming in any way? Because as an engineer or developer knows, writing code is just a small part of the whole process of creating software.
“Processing large amounts of data? Software’s great at that. Figuring out what a human wants, or what a usable UI is like, or what the real problem you need to solve is… those are hard”, says an entry in the blog Code Without Rules titled “When AI replaces programmers”, which goes directly to the big issue in a future of machine-produced code.
Although there have been some advancements on the idea of teaching an AI to write code and produce entire programs, like the experiment done by Andrej Karpathy in 2015 where he trained a neural network with GitHub’s Linux repositories to write its own code, the results are still mixed. According to the site Perforce.com:
“[The] AI generated code (including functions and function declarations) overnight. It had parameters, variables, loops, and correct indents. Brackets were opened and later closed. It even had comments. However, the AI produced code had syntactic errors. It didn’t keep track of variable names. Sometimes variables were declared but never used. Other times variables were used but not defined.”
Of course, this was way back in 2015, and the technology behind these networks has only improved since then, but the actual viability of letting a machine program by itself one day, especially for more critical areas like Defense, Finance, or Healthcare, it’s still far away and will still be at the mercy of human instruction.
The advantage of outsourcing these kinds of tasks, be it to a remote developer or an entire Nearshore company, is the ability to communicate clearly anything you may want in the software produced. Collaboration is constant, communication is key, and the skill to apply different ways to solve issues is a given in any valuable development team.
This is to say, the “creativity” involved in these kinds of efforts is still a long way off, and having this skill while programming is critical to producing code that solves actual problems and accomplishes the expectations of both clients and final users.
“There have been some experiments before, even since the 90s, with tools whose purpose was to generate applications”, explains Adolfo Cruz, Scio’s Project Management Director, and the best person to have an idea of where this technology is going. “If you wanted to generate a User Form, for example, you defined the parameters (first name, last name, age, date, etc.) and these programs delivered a simple but functional result.”
“Those very early tried, but they worked and now it’s evolving to full-on Artificial Intelligence. However, if these tools become a reality, they’ll probably lack the spark of human imagination. During development, a programmer sometimes gets ideas about cool features that could add value to a project, and these kinds of things will be difficult to achieve for a machine.”
“But beyond that, I think we’ll see software coded by machines. Maybe there will be a point when an AI can understand and interpret the user, getting a command like “create a chat program” and propose three options, which can be narrowed by the user.”
For sure, these three options would not take any time at all for a machine, but deciding which path to take from there, refining and redefining options, could be a tiring process, although, in terms of man/hours invested, it’ll need a lot less effort than having multiple people working on this same project.
“Still, there are a lot of questions unanswered”, Adolfo concluded. “How long would it take to explain exactly what you want, what frustrations would that cause, and how that impacts the adoption of this technology is a whole discussion to have. It’s not simply about technical feasibility, but acceptance among the public.”
The December holidays are the perfect moment to look back and celebrate the best things that happened this year. Or in the case of Scio, celebrate all the technologies that manage to make our lives a little easier in 2021, which is why we are taking a look into one of the most surprising tech resurgences: the QR code and all the solutions it brought to us during the pandemic.
It can’t be denied that, for a moment, the idea of receiving information just by scanning a picture sounded like something out of an old Sci-Fi novel. And for a brief period at the beginning of the New 10’s, QR Codes (and the whole idea of “Augmented Reality”) seemed to offer a preview of that exact future.
It didn’t turn out quite like that, sadly. Although it had its particular applications, QR’s never lost a certain “novelty” vibe, a gimmick that most of the time brought more complications than true convenience.
On one hand, the need for a special reader capable of recognizing these codes (which not many phones at the time included right out of the box), and a stable Internet connection to actually check the content was already a high barrier in 2011.
And on the other, integrating QR’s in any kind of visual design, like in an advert, was always difficult, because they almost never mesh well with any composition, so it’s easy to let them overshadow every other element of the image.
So QR Codes, although an interesting idea, looked like an artifact of the smart device boom of the 2010s, and by the end of the decade, the world seemed ready to leave them behind.
What happened, then?
If we look closely at this Google Trend graph, we can see how the search term “QR Code” had its first sudden popularity spike in years. The date? August 22nd, 2020.
We all know why. Thanks to the pandemic, we were forced to take distance from everyone else, and a lot of our normal interactions had to fall back on technology, forcing us to look for quick solutions in a time we couldn’t do anything else.
This graph is about the United States only, by the way. If we look at a worldwide trend, well…
We can see a noticeable growth signaling that QR codes maybe are finally here to stay. But beyond the pandemic, what does this resurrection means, and why has this technology becomes part of our daily life?
A story of highs and lows
These codes have an interesting story, because their popularity has never been uniform, and it has suffered a somewhat fluctuating implementation for the last 30 years.
Let’s not forget that “Quick Response Codes” have been around since 1994, as an invention of the Japanese automobile industry, used to codify the biggest quantity of information possible, while compatible with the notoriously tricky kanji alphabet (at least in regards to software).
This huge amount of info in every code (inspired by the grid of a Go board) made QRs codes popular, and little by little it started to see some applications beyond tracking auto parts: virtual business cards, instant Wi-Fi connections, and even the aforementioned Augmented Reality.
And even after this tech didn’t seem to have a bigger impact among consumers, it never really went away, becoming an expected feature of many smart devices which, along with better mobile Internet connections, made QR codes singularly well-positioned when the pandemic demanded quick and trustworthy solutions.
By condensing a lot of important info or giving a quick link to elsewhere without any direct contact, things like menus, information about attendance capacities at any place, or any change of services announcements could be conveyed through a QR code, making them an important tool to take care of our health.
And this late adoption doesn’t show signs of stopping; just as we can’t imagine a near future without medical masks or anti-bacterial gel, QR codes are now a normal part of our daily interactions in many places, probably on their way to becoming a normalized and accepted means to interact with our world.
That’s why we celebrate a technological solution that we took for granted at some point, or whose real value needed a very specific context to shine: when the distance between us became a necessity, a simple code and a camera gave us a way to keep parts of our daily life functioning.
When building any kind of company, there are steps you must take that will do the most to ensure your success. These steps are especially lucrative when building a company that works for other companies such as the ever-growing industry of software-as-a-service. It may be difficult to know on your own what are some of the ways you can ensure success in your software service company. To make it simpler for you, we have compiled a couple of the ways that you can see to it that your company has the best shot of success.
Keep it simple
Because software is often self-serve it is best to keep it simple and easy to use considering the majority of business owners aren’t computer geniuses. Making it more user-friendly will mean that more people will want to use your software for their business. Keep it simple, tidy, and user-friendly.
Never stop improving
One way that a lot of software service companies fail is that they become complacent with their software. A good software service company listens to their customers and continuously improves and updates its product to make it work even better and smoother. Monitoring what the consumer is saying allows the software service company to cut out unnecessary functionality which ties into the “Keep it simple” rule.
Offer several different packages
You should always have more than one package available where the first and lowest functioning one is basically free. From there you can increase the price per software based on customer needs, usability, willingness to pay, and ROI.
Display a path to profitability
Oftentimes a company will not be profitable simply because they invest their resources to sustain growth. Good service software companies must show that they plan to be profitable in the next few years and that they have a path to profitability. The best way for a company to achieve this is to hit profitability every couple of years before reinvesting.
Offer the perfect mix of services
Offering the right amount of services can be difficult for a company but it is highly lucrative to the success of a said company. On one hand, they increase revenue and reduce churn rates whereas on the other hand they reduce margin and increase deployment time and cost of sales.
Commit to the success of your customer
One of the most important things to remember when growing a software service company is to sign new customers as well as commit to grow and secure its recurring revenue from previously signed customers. To accomplish this, the company must be monitoring its customer’s usage levels continuously as well as send them customer satisfaction surveys and product updates among other things.
These are just a few of the major points to remember when you are trying to build a successful and profitable software service company. Along with these, you will find that you discover things that work for your company and your specific product and what does not.
Scio provides end-to-end engineering services in a collaborative partnership to ensure that your team is an integral part of the solutions you require. We can offer a wide range of skills to make up a team that you can depend on – and work with directly. And when you need something more – we’re flexible. From helping to assess your needs to developing, implementing and maintaining solutions, we can offer as much or as little help as you need. Our teams can work with you virtually or on your site – but most companies need some type of combination of the two and we’re more than happy to find that blend too. If you think that sounds interesting – Contact Us. We’re ready.
Our Service Delivery Manager Rod Aburto and our PMO Adolfo Cruz attended the 5th SaaSt Annual event. They were lucky to hear from the best executives, founders, and VC’s in SaaS. In this article, they share with us their experience and some key points that were covered through the event.
What is the SaaStr Annual?
In their own words: “The 5th SaaStr Annual is the largest non-vendor confab in the world, uniting the global B2B SaaS community both online and off. We want to help everyone scale faster and with less stress and more success!” Here’s a couple of facts around it:
12,500+ SaaS executives, founders, and VCs come together for the SaaStr Annual
3+ full days with 200+ sessions from the best-of-the-best on how to scale faster
100+ of sponsors
250+ VCs, including an entire day where the VCs pitch you
300+ speakers from the best SaaS companies across the world
Scio Consulting at SaaStr
We have been attending SaaStr Annual for a couple of years ago, and we can say the event gets better and better each time. It was certainly better organized than the previous year. San Jose Convention Center is a venue suited for such an event (3x bigger than the venues in 2017 and 2018), so we gladly welcomed the news when we hear SaaStr has moved out of being held at a hotel. As usual, we got 2 main reasons to attend:
Get first-hand information on today’s SaaS industry trends and tips for helping companies grow
Networking and meeting people, talk about their own experience and share ours
Takeaways from SaaStr Annual 2019
Here’s a list of great ideas we gathered during the event, be sure to adopt and adapt as required!
1. Generational Companies as a goal
Both during the Opening Remarks and along several of the sessions, the aspirational goal to maintain this year was “Becoming a generational company”, not just a unicorn, but a company that transcends generations and becomes a $1,000,000,000+ in Annual Recurrent Revenue (ARR)
2. The Sales Funnel, no more
Main speakers reiterated on the idea of chasing a Sales Flywheel instead on a Sales Funnel: turning leads and current customers intro promoters and evangelists.
Define Goals for Recruiting, assign topics or areas to the team interviewing (Intentional roles)
Stress on finding talent aligned to company values
Don’t include very busy developers on the Panel per default
Normalize interviews company-wide
Interview training is reviewed annually
Include people from Learning and Development in the panel
From the session: Setting Up a Good Hiring and Interview Process (Jully Kim from ZenDesk)
6. How to move upmarket
If you want to move upmarket, focus on growing your user base with a plan to land with companies, don’t sell to the C-suite, at least not at the beginning. You need to grow your user base because they will be your best sales agent within their organizations to adopt your solution at an organization level.
7. Facts about free trials
Time-based free trials are the most common because they convert up 2x better than other models like feature or seat trials. In terms of free trial duration, 14-day trial is the most common for a couple of reasons:
Trial length has no impact in conversion
Time kills deals
8. Talent is everywhere
SaaS companies are struggling in hiring local talent, especially in the bay area, many of them are building teams in other parts of the US or other countries but, to make it work, 2 aspects are essential:
Find leaders that you can trust and let them do their work building and managing distributed teams, don’t become a bottle-neck trying to control everything from your main office
Treat distributed teams as equals, they happen to be in other cities, in other countries, but they have the talent to deliver value, give them meaningful work
9. Miscellaneous ideas
Partnering for growth:
You should build both indirect Channels and Platform Ecosystems
Aim to offer developers oriented platforms: Business to Developers (B2D)
How New customers are deciding:
Trust has moved from Brands to Referrals
You need to nurture your happiest customers to bring more business
In summary, take care and grow your user base with a plan to land in companies, let the users play and try your complete solution for a period of time, and you can build your solution with a distributed team that you trust and treat as equals.
What do we think of the event?
We enjoyed participating in SaaStr Annual 2019. It is a vibrant community, full of knowledge and opportunities. Knowing the latest trends in the SaaS world allows us, at Scio Consulting, to propose new ideas and solutions to our clients that are aligned with what consumers/users are expecting.
Software development can be complicated, often involving a high level of knowledge and expertise. And even for those with development experience, working out all of the issues within an application to ensure that the client is provided with an acceptable solution can be difficult. It is for this reason that many software development companies use a QA or quality assurance team for testing apps. Here are the best practices for quality assurance in software development.
What is Quality Assurance (QA)?
In essence, QA is simply a means of making sure that the demands of the client are met with a high-quality product. Assessing the quality level is typically the job of the team member that is filling the QA role. The primary goal for a quality assurance professional is to ensure that the end product is not hindered by any defects introduced during the development phase. In most cases, software that has been developed for a client will be given to the QA analysts for testing before it is deployed.
Why are QA Best Practices Important?
There is an array of reasons that utilizing the best practices during software development is important. First and foremost, the QA role will have an arsenal of automated tools that help in working out issues within the software. These tools can be used to assess scripts, validate applications, and provide an overall structure for the engineering workflow.
Another thing that makes the QA role valuable is their understanding of the code that is being used in the application and this can help them to identify trouble spots that must be worked out before delivering the product to the customer. Once the QA department has discovered a section that may be problematic, they can review the code and make educated decisions on the steps that should be taken to remedy the situation.
QA Leads to Lower Development Costs
It is no secret that software development is a time-consuming and expensive process. Any unwanted delays or coding issues can end up costing significant amounts of money and may deter clients. And while some may argue that it can be expensive to retain personnel for QA purposes, their role within a software development company is vital. After all, it is always better to provide a client with software that has been thoroughly checked for quality issues, than to give them a program full of glitches.
In Summary
There are few roles in the world of software development that are as crucial to the success of the final product as that of a QA professional. By allowing the QA team to test code scripts before they are received by the client, you will help to ensure that the software will function correctly once it has been deployed. In addition, the QA role can actually lower costs by detecting issues before they are noticed by the customer. When you are having an application developed, make sure that it has been put through the proper quality assurance steps. A new tendency is to stop separating the QA role completely from the Developer role, so developers themselves test the software and help maintain automated tests up to date, achieving the required testing and making sure no issues are kept before delivering the solution to users.
