What works, what doesn't, and what to do next.

In today’s fast-evolving tech landscape, small teams are often at the forefront of innovation and development. However, these teams face significant challenges such as resource constraints, the need for rapid development cycles, and the demand for high-quality outputs. Agile methodologies, known for their adaptability and collaborative approaches, present a powerful solution. This blog post delves into how small tech teams can harness Agile methodologies to streamline their product development processes, emphasizing speed, flexibility, and quality.

In the ever-evolving web development landscape, keeping pace with emerging technologies is imperative. The concept of Edge Functions stands at the forefront of a transformative paradigm shift in cloud computing that brings computing closer to data sources, significantly enhancing processing speeds and reducing latency. This breakthrough opens the door to a wealth of possibilities for real-time applications and highly responsive user experiences.

Recently, we have been exploring the world of Edge Functions with Supabase, where the synergy between these technologies empowers developers to craft applications that are not only robust and scalable but also lightning-fast, with an unprecedented level of efficiency and adaptability.

Form validation is an essential feature for any application that collects user input. It ensures that the data entered by the user is correct. Without validation, our database would be filled with incorrect or incomplete data which would lead to errors, security issues, or a poor user experience.

In this post, we will be looking at how to validate a form with React form using as an example an application to reserve office spaces, built using the Expo ecosystem and Supabase platform as the storage manager.

Ever felt the frustration of coding complexities or the joy of seamless teamwork? In the ever-changing world of software, our guiding stars are Comprehensive Documentation and Best Practices. These aren’t just tools; they’re the secret sauce that turns challenges into triumphs. Buckle up as we unravel the power of these essentials, transforming your development journey into a collaborative, efficient, and innovative adventure.

Keep It Comprehensive Yet Concise

In the realm of documentation, less truly becomes more when you can convey a deep understanding without drowning the reader in a sea of words. This principle is not just about brevity; it’s about effective communication. By embracing this concept, you create documents that are not only informative but also engaging, making the learning process smooth and enjoyable for your audience.

In today’s rapidly evolving tech landscape, efficient software development isn’t just about writing code; it’s about embracing collaborative methodologies that ensure seamless integration, swift deployment, and continuous innovation. DevOps practices stand at the forefront of this paradigm shift, fostering a culture of cooperation between development and operations teams. In this blog post, we’ll explore the fundamental principles and benefits of DevOps practices, along with practical tips for software developers to integrate them seamlessly into their workflows.

In the dynamic realm of software development, collaboration is the bedrock upon which groundbreaking innovations are built. Efficient collaboration within a development team not only fosters knowledge sharing but also significantly impacts the quality and speed of software delivery. In this blog post, we delve into two powerful strategies – Pair Programming and Code Reviews – that have become keystones in the modern software development process, enhancing teamwork, productivity, and code quality.

In the world of design and software development, the journey from concept to the final product is a complex and intricate process. Designers play a pivotal role in this journey, bridging the gap between ideas and tangible outcomes. One essential tool in a designer’s toolkit is the creation of effective mockups. In this blog, we will delve into the art of creating effective mockups and how they can lead to better outcomes in the software development process.

Strong teams thrive on connections and effective communication. Team bonding activities foster trust, while good communication skills enhance collaboration, decision-making, and productivity. Develop skills through training and create an open communication environment with your team.

Fostering Connection

Connection is another important element in building stronger teams. When team members feel connected to each other, they are more likely to trust and support one another. This sense of connection creates a positive and supportive work environment where individuals feel comfortable expressing their opinions and ideas. Team members who feel connected are also more likely to go above and beyond their assigned tasks to help their colleagues succeed. By promoting connection among team members, team leaders can create a cohesive and high-performing team that is capable of achieving great things.

Outsourced development is a game-changer in the world of technology. It allows companies to tap into a global talent pool and bring together teams of experts from different corners of the world. The possibilities are endless when it comes to outsourced development. Companies can now work with highly skilled professionals who have specialized knowledge and experience in various areas of development. This means that they can tackle projects that were once considered too complex or time-consuming. With outsourced development, companies can accelerate their product development and bring innovative solutions to market faster than ever before.

In the intricate world of software development, a shift has occurred from traditional management structures towards more fluid and adaptive frameworks, with Agile sitting at the forefront. At the heart of Agile’s success lies a fundamental component - effective team communication built on a foundation of trust. This trust is not only instrumental in fostering a collaborative environment but is quintessential in navigating the labyrinthine corridors of project development where adaptability to change is the norm, not the exception. Here, we delve deeper into the nexus between Agile methodologies and the symbiotic relationship between team communication and trust.

In an interconnected world where we see a rapid growth in the number of new libraries and tools that are available for development and in general, for technological advances, one important consideration leaders and teams should take into account is the licensing of the software they are using. Open source is an important weapon in the arsenal of any software development team, but it’s important to understand the different open-source licenses and how its usage may impact your application.

The acronym stands for Application Performance Monitoring (and also Application Performance Management, but we will only focus on the first one) and it refers to the monitoring of telemetry data to measure our system’s health, and availability, or even to troubleshoot problems while it is online.

APM is a means to increase the observability aspect of our system, allowing us to know about its internal state by reading through its external output. Now, before we dive deeper, let’s briefly go over some concepts that were just called out to ease the understanding of this subject.

Fly.io is a cloud platform for hosting and deploying applications. Its simplicity, performance and affordable pricing make it a no-brainer choice for startups and works very well as a replacement for Heroku. In this post we will show how to deploy a Buffalo application to Fly.io.

Initializing the Buffalo application

Initializing a Buffalo application implies running the new command on the Buffalo cli. To make things simpler we will create a SQLite application

One of the coolest libraries in the Buffalo framework is Plush, a templating engine that provides ERB-like syntax for writing server side HTML. It is a very powerful templating engine that can be used to render HTML pages for Go applications. Plush makes it easy to iterate over collections, have conditional content, use partials and more.

Even though Plush is built within the Buffalo ecosystem and I’ve been able to mostly use it in my buffalo apps, I’ve always wondered how it can be integrated with Go applications written with the standard library. In this post I’ll show you how to use Plush to simplify your templating needs in your plain Go applications.

I recently tried to build a web application using Go and HTML templates. In doing so, I started to miss some cool features that Buffalo and plush have to avoid repeating the layout of your web pages. I thought this was a common enough problem that the Go team should have provided the tools in the standard library, and as usual, they did. That’s when I came across the block and define expressions for templates. In this post I will explain how to use these to avoid repeating the layout of your web pages.

With the Go 1.16 release the Go team added a new way to embed files and folders into Go application binaries. This is a great feature as it facilitates a practice that is common in the community and much likely loved by many gophers: shipping a single binary with embedded assets. In my case it even makes me wonder if there is a need to use Docker to deliver our Go binaries, but that’s another topic.

On a previous post I wrote about Go’s time locations and how to put those in an alpine Docker container. This was achieved by copying the timezone data zip file from the docker builder image into the distributable image. Then using an environment variable to point Go to the location of that file.

Over the years, Android developers have been doing networking with the use of some APIs from the Android SDK and other tools which always involved a lot of work. The use of Retrofit became the standard when we are talking about consuming APIs. This means having an additional layer on top of Java and the logic of our app.

With the introduction of Kotlin a few years ago and with their native support for asynchronous operations with Coroutines, developers were provided with tools easier to use. Retrofit is still needed though, but getting out most of the language feels like if we are not using it.

We may have come across the need of having to create multiple records in a single operation. Now, this can be achieved through a single insert command of course, but the more records we require to persist the longer it’ll take for this entire operation to complete.

Let’s set up a basic example to go over this topic. We will be creating a list of contacts in bulk using the database/sql library in Go.

In Go, a build tag is an indicator that is added to a piece of our code, to indicate when a package will be included in the building process. This gives us the possibility to compile different versions or parts of our application from Go, switch between them in a fast and organized way, and all from the same source code.By using the build tags we can work on integration tests in development teams, which allows us to test the updates of our code without the need to make modifications to the already tested sections of it.

You might have read an article I wrote before on how to run your buffalo container on CloudRun, however a lot has changed in CloudRun since I wrote that article and I noticed that I missed important details that will be needed to run your application there. In this article I will cover how to run your buffalo application in CloudRun (GA now).

Overview of the Application

I think is important to describe a bit of the app we’re deploying in order to understand what we’re trying to accomplish.

Martin Fowler in his book defines refactoring as “a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior”. This book contains a long list of refactorings techniques that mean to be applied under certain scenarios and with the intention to eliminate “code smells”.

Refactorings are a very extense topic and I’ve found them to have an important role in the software development process. Their relevance is such a high that they are an essential component for TDD life cycle.

My team has faced an issue with timezones repeated times: Apparently, default Locations were not present in our production deployments of our apps, that took us by surprise given locally these were present and working nicely 🤔.

This is an issue I’ve faced before. Every time I wanted to show dates in a certain timezone but such timezone was not present in our production environment, Our app ended up in GMT for everything, or we had to create our own locations.

One common Javascript flaw I see in repositories I get in touch with is the usage of both yarn.lock and npm-lock.json. This is not on purpose, in most cases is due to the lack of communication on the tooling the repo uses or different points of view on the best tooling for the problem at hand.

In this short post, I’m not going to focus on communication strategies for the codebase, nor in which one is better between YARN and NPM. Rather I want to share a small tip on how to prevent the usage of NPM when your team decided on YARN and vice-versa.

Buffalo is a great tool to rapidly ship software solutions to the market, inspired by the famous Ruby on Rails framework, it brought Rapid Application Development to the Go Language. I say Buffalo, by far provides the best developer experience among other web development frameworks in Go, but I’m obviously biased by being part of the Buffalo core team. Buffalo’s existence has lead my team at Wawandco to deliver great apps within the last 2 years, and we are still delivering.

From my experience as a software developer, an issue that I have dealt when building an application are the dependencies for external services. A test with external dependencies where you don’t have much control can fail if there is a change in the service and the outcome is not the expected, with this in mind, we need to ensure the non-dependence of external services when running our tests. The most effective way to do this is mocking those dependencies.

In this post, I will focus on the functional tests of an application. I will also talk about how to mock an external service to not rely on it when running our functional tests.

To explain how to mock an external service, I’ll walk you step by step through an example.

Let’s say that we have an endpoint, that is using a third-party package called holidays that is making HTTP requests to an external service to get such holidays.

First, for Java developers only

As Android developers, there are many ways to write an app and get tired of seeing how the lack of features of the Java (Java6 by default) platform embedded in the Android SDK slows the coding process. Notice that Java6 last public update dates from 2013 and that is the version you are expected to use on Android development with Java. You can use Java8 language features but most of the powerful features can only be used in devices that are running Android 7.0 Nougat (API 24).

The following chart from May 7, 2019, taken from Android’s “developer dashboard,” with Android 10 not yet released, shows a total of nearly 41.9% of devices running Android OS prior to Nougat out of 2.5 billion billion active devices.

In certain situations the site or app you’re building uses fonts that are not hosted in a CDN. The font is not in Google fonts, and is not in Adobe Fonts or other provider.

You may be given at that point a set of OTF, TTF and WOFF files. But what do do then? How do you integrate those font files in your Buffalo app?. After all, you want your frontend to look as closer to what your designer has put together, And we all know that fonts matter.

What to do?

Assuming you are in your Buffalo app folder, take a look at the assets sub-folder.

- assets
  > css
  > images
  > js

As developers one of our duties is to ensure consistency in how content is displayed in a variety of browsers. If your web development project involves testing the visuals on IE11 or Microsoft Edge and don’t know how because you are using MacOS, then this post is for you! Note that you do not need a serial number or purchase anything in order to install Windows 10.

I’ll expose a fairly simple and popular way to operate Bill Gates’ giant having Steve Jobs as host using Oracle’s VirtualBox. The steps are as follows:

1. Install Oracle’s VirtualBox. 2. Install Microsoft 10 using a .iso file in VirtualBox. 3. Testing your project with IE11 and Microsoft Edge.

Disclaimer. Those who are not familiarized with N+1 problem, you can check “What is the N+1 selects problem in ORM(Object-Relational Mapping) with details explaining the concept.

Since associations were introduced in Pop, the N+1 problem became part of it: many queries hit the database in order to load whole model’s associations. Good news is N+1 problem is not a disease without remedy. In this post I will give you some steps I took to solve it by incorporating emergent design.

Step 1: Start Coding By Example

Coding by example helps you to define what’s your input and what’s your output. Code By Example means you define a scenario where  your solution is tested and what is the expected result. The method I used to apply this technique was Test Driven Development (TDD).

Sendgrid is one of the most well-known and used email delivering solutions. It has solutions for most (if not all) of the common email sending and delivering issues that we could face as developers. But this post is not about convincing you to use Sendgrid.

One of the things I love about Buffalo is that it ships with all of the things a product needs for rapid application development and deployment. In this case that is email. Buffalo has a mail package that you can use to integrate sendgrid or any other provider with your app.

import github.com/buffalo/mail

Buffalo’s mail package key items are the Sender interface and the Message struct. It also ships with an SMTPSender implementation of the Sender interface which could be used if you have an SMTP server or want to use your gmail/hotmail email to send emails. I do not recommend you to use a single email account for SMTP on production environments but it could be useful when doing very quick iterations and hacks.

Sender interface

The Sender interface is a very simple interface which is defined as:

Google Cloud Run is a service that allows you to run containerized applications in a serverless environment. This means that you don’t have to care about servers. Billing is done for what you use in terms of memory and processor for time (Google provides a free tier you can check here).

In this post, I will describe how you deploy your Buffalo application to Cloud Run.

Setup

In order for us to be able to send the app to Google Cloud Run, you need:

• Docker installed
• Gcloud CLI tool installed with the beta components
• Gcloud logged into your google account
• Docker setup with your GCR account

A lot of things have changed in the Buffalo ecosystem since my last post on how to deploy to Heroku from Gitlab.

Indeed, everything has changed since I posted how to deploy from gitlab repo into Heroku with the birth of the buffalo-heroku plugin. In this post I will try and describe how to use it to deploy your buffalo app to Heroku.

Setup

First thing you need to install (or ensure you have) is buffalo-plugins plugin. If you’re on buffalo v0.14.6 or higher you’re all set. If you’re on an older version you should:

1. Move to your project root folder
2. Download and install buffalo-plugins plugin

$ GO111MODULE=off go get -u github.com/gobuffalo/buffalo-plugins

Buffalo already ships with very cool pagination support, more than that it even uses the pagination when we generate resources, which is awesome.

I’ve been working lately in a project that uses that pagination (again thanks to the buffalo team), but this app also has a page indicator on the left side, as the following image shows:

Yes, i’m talking about the section that says “Displaying 1 - 25 of 120 Policies” (design typo there).

So my first thought was computing those variables on the action and then passing these to the view, where i would use them to build my “page indicator” section.

As some of you may know, our team has been working with Go for some time and we have always been using CircleCI to run our test suites, we would like to share our circle.yml file, it would help for your Go projects.

machine:
  environment:
    GOPATH: /home/ubuntu/.go_workspace
    IMPORT_PATH: "github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME"

dependencies:
  pre:
    - go get -d ./...

  override:
    - mkdir -p "$GOPATH/$IMPORT_PATH"
    - rsync -azC --delete ./ "$GOPATH/$IMPORT_PATH"

test:
  override:
    - cd "$GOPATH/$IMPORT_PATH"
    - go vet "$IMPORT_PATH/..."
    - go test "$IMPORT_PATH/..." --race --cover

test:
  override:
    - go vet ./...
    - go test -v ./... --race --cover

Enjoy!

In part one I talked about what refactoring is and all stuff related to that. In this post I want to show you how refactorings are related to frameworks and give you a real example of their use.

Frameworks were design to make your life easier in some way, and they should fit to solve your problems. Nowadays developers rarely build apps from scratch, we use frameworks according to our needs to speed up construction, testing and delivery. You realize that get used to a framework doesn’t mean you are except from live without code smells. You can actually apply refactoring techniques using the components and elements those frameworks provide.

To give you an example, last week we were working in an app which was built using Ember.js framework, while we were in a manual code review activity, we found some duplicated code into three route components.

Let’s imagine you want to visit a friend in town but you don’t know where he or she lives, so you call him/her and ask for his/her address. The address becomes your target place, it’s the place where you want to go. When you are about to decide to move, you think, what path should I take so it can lead me to my destiny?…So your options are probably based on less time path, or more secure path, or nearest path. After you decide to use a path, you move and follow it until you end at your destination (your friend’s house).

That kind of thinking is a little bit related with the concept of refactoring. Imagine now that the situation is not to visit a friend but to extract a piece of code in your app. With that piece of code, you want it to live in a new method, the new method now becomes your target (the place where you want to go). So you think again, what path should I take to put that piece of code into a new method in a safe way?…

In 2013, Organization for Economic Co-operation and Development accepted Colombia as a candidate to become an active member of this privileges countries group. If Colombia accomplishes all the requirements for membership requested by OECD, it would be part of “the best practices club”, where countries with better perspective and better performance in social and economic fields help each other to improve their public politics quality, which means more investment, more employment, more capability.

There had been great progress in some areas along these two years. One of the greatest progress made in Colombia is related with IT investment. With help of ICT ministry and FITI, some programs were developed to help entrepreneurs to create businesses around IT technology, programs to capitalise IT professionals which offer free certifications, free scholarships for MBA and PHB degrees related to IT industry, I+D+I, just to name a few ones.

An info-graphic emitted by ICT ministry for the last four months of 2014 shows how IT technology has improved its use and capability to coverage almost the whole country. Also, statistics from the same source show how GDP had behave in a decade thanks to IT investment.