DEV Community: EUDA

¡Ayuda! Necesito una APP

Euda — Fri, 31 Mar 2023 00:50:18 +0000

Aplicaciones vs páginas web: por qué es importante customizar tu plataforma en base a las necesidades del negocio

Comunicar en la virtualidad

Las aplicaciones móviles, redes sociales y páginas web tienen un punto en común: son excelentes herramientas de comunicación. Sin embargo, hay algunas ventajas de las apps (aplicaciones móviles) que deberías tener en cuenta.

Como empresa, negocio o emprendimiento tenemos múltiples tipos de contenidos para comunicar: videos, eventos, imágenes, textos, audios. Por eso, trasladarlo a una plataforma que combina todos estos elementos en un solo canal es un gran beneficio.

Las aplicaciones pueden incluir archivos multimedia, textos, datos, realizar llamadas, brindar servicios de geolocalización y mucho más, sacándole provecho a las capacidades que ya vienen integradas en el teléfono. Hay quienes dicen que hoy en día el teléfono inteligente o smartphone es una extensión del propio cuerpo, por lo que, imaginemos toda tu información al alcance de todos, en la palma de la mano de a quien querés llegar.

“Sin apps, los teléfonos inteligentes y las tabletas serían como vehículos de sofisticados diseños, pero sin gasolina.”

La particularidad de esta herramienta, no es solamente la capacidad de contener varios formatos y tipos de archivos, sino también su versatilidad para un fácil acceso. Muchas empresas han querido aprovechar esta tecnología, en algunos casos, con suficiente éxito, como son los bancos e incluso instituciones estatales y gubernamentales. La virtualidad puede ser compleja, pero hay herramientas que nos acercan cada vez más: asistentes virtuales, chatbots, entre otras.

Oportunidades de negocio

Uber, Rappi, PedidosYa, Spotify, Brubank y más: todas aplicaciones que surgieron a partir de necesidades concretas. Los empresarios encontraron un nuevo nicho para explotar, y el acompañamiento de la tecnología fue clave para poder efectuarlo.

El e-commerce se encuentra en alza al punto que las tiendas físicas o retail en todo el mundo están buscando nuevas soluciones para mantenerse en pie. O por el contrario, nuevos negocios como showrooms o pequeños emprendimientos aparecen y se promocionan en redes, pero subsisten únicamente en lo digital.

Sin embargo, ya sea una plataforma para e-commerce, una plataforma para reservar turnos o gestionar paquetes y envíos, la mejor opción es una aplicación personalizada. Si bien las redes o páginas web -como TiendaNube, Wix, entre otras- son muy útiles para los negocios que están empezando, al momento de crecer es un beneficio tener el poder de customizar tu plataforma y no depender de las limitaciones de estos prestadores.

Al fin y al cabo, es el medio de contacto más importante con tus clientes. Si no tuviese una página web o aplicación propia, durante el apagón de Facebook, Instagram y Whatsapp muchas ventas cayeron y, más importante, se perdió la comunicación con el cliente.

PWA o Progressive Web Apps

Actualmente, hay muchas opciones a considerar, como una Progressive Web App o PWA, es decir, una aplicación web con características de aplicación. Es el híbrido perfecto entre una app y una página web: puede soportar las mismas funcionalidades que una aplicación -como, por ejemplo, realizar videollamadas, chats, geolocalización- desde una url para usar en cualquier navegador, tanto en el teléfono como en la computadora. Es fácilmente adaptable a todos los formatos y pantallas.

Entre las ventajas de esta solución, podemos mencionar:

No es necesario instalar una aplicación desde el Google Play o App Store, ya que funcionan en cualquier navegador como Chrome, Safari, Firefox, etc.
Puede funcionar sin conexión a internet, en algunos casos. Dependiendo de la funcionalidad que se le da, como una app, no es necesario que tenga conexión a internet para mostrar su contenido.
Permite enviar notificaciones push a los usuarios, sin que el usuario haya instalado una aplicación.

Asesorate SIN COSTO

Con tantas variables a tener en cuenta, un asesoramiento personalizado será siempre lo más valioso para que tu negocio crezca. Si te interesa escalar tu negocio no dudes en contactar una entrevista SIN COSTO con nosotros.

Y si todavía no me creés, mirá este caso de éxito dónde uno de nuestros clientes cuenta cómo lo ayudamos a escalar su negocio.

#EudaStyle, long-term quality

Euda — Tue, 21 Mar 2023 13:22:11 +0000

We build software with processes that help your digital project take off

Creating an app is a science that needs quality and precision. With more than 12 years of experience innovating, at Euda we use the same top-notch processes as other well-known tech giants. In this article, you’ll find what are the first-class technology and work processes that we use to develop our success stories’ apps.

There are a lot of things that can go wrong working in IT. For instance, a junior developer accidentally erases a whole production database of an e-commerce app and it affects not only the work of hundreds of people but the final customers. Or, maybe there is a bug that can stop the production of a whole factory, generating huge financial losses. Security is key and this is why we work in a way to ensure all these examples mentioned above never happen.

Cross-code control

Code review between cross-hierarchy teammates is one of the many actions taken to prevent this. Developers proofread each other’s lines of code before updating it on the system, checking each other’s code for mistakes.

Quality Assurance

Another important point is QA, with manual and automated testing. Most IT companies provide this service for their products. However, there are some key points to make it even better. For instance, automated tests should be integrated in the pipeline so that they run automatically with every deployment.

Regarding manual testing, although they may sound similar, there is a huge difference between a bug and a glitch. Bugs are usually coding errors, whereas glitches are errors that happen when the engine does not work as expected. Also, there are some metaapp features that may become bugs if the final users don’t like them. This is why our QA engineers always test with an open mind and anticipate both users’ moves and their expectations of the product.

Agile Methodologies

One may believe that organizing beforehand to achieve a perfectly calibrated work before starting any project allows us to accomplish better results. However, calibrating work such as an analogical clock may take too long. The formula used in our success stories involves bumpy starts and lots of refining later, and I believe that, in most cases, this is better than no starting at all. Refining tasks is the core of agile methodologies and combined with high quality processes is how we carry out extremely complicated projects at Euda.

We believe that organising work by following the agile methodologies principles is the way to go. Through our work we have come to value:

Individuals and interactions, over processes and tools
Working software, over comprehensive documentation
Customer collaboration, over contract negotiation
Responding to change, over following a plan
Find out more information on the Agile manifesto.

Multiple development environments

Moreover, safe and independent environments for development, testing and production ensure safety and quality at every step. Junior developers must learn from others and test in their own local environment and, again, before having access to production their code is reviewed by others.

Automation: continuous integration, delivery and deployment

And last but not least, we use tools such as Jenkins and Bitbucket Pipelines to ensure that the state of development is always available and transparent, and that a compiled application can be accessed at any time. That's how we focus on CI/CDD or Continuous Integration, Delivery and Deployment.

Following these principles, we had achieved digital projects’ scalability and product quality. It does not rely only on essentially big and complex teams. We believe that small but organised teams, added to all the good practises highlighted above are the best foundations for great software development.

Want to be our next success story? Visit our website to find out more and do not hesitate to contact us!

Sails development with Docker and Docker Compose

Euda — Wed, 14 Apr 2021 14:18:32 +0000

Docker makes it easy to set up and run a development environment and also simplifies the deployment of your applications. In this article we will see how to setup a Sails development workflow with Docker and Docker Compose.

Whats and whys: Docker & Docker Compose

The goal of this article is to make setting up a Docker workflow for Sails as simple as possible. Docker makes it easier to set up and run a development environment and also simplifies the deployment.

First, we’ll get into how Docker and Docker Compose work and its benefits. Then a step by step guide to make our beloved Sails run inside a Docker container. Let's get started!

Containerization

Before talking about Docker and Sails we need to understand what is containerization and why we want it.
Containerization is a form of virtualization, through which applications are run in isolated user spaces called containers. We can think of a container as a lightweight virtual machine (but to be clear, it is not).

Comparing Containers and Virtual Machines [1]

But, why do we want it?

With containerization, everything an application needs to run, let's say, its binaries, libraries, configuration files and dependencies, are encapsulated and isolated in its container. This makes it easier to set up and run a development environment, and also simplifies the deployment by reducing the chances of missing or different versions of libraries, files or dependencies errors.

The container itself is abstracted away from the host OS, with only limited access to underlying resources. Isolation has its advantages, for example portability, stability and security.

So, standard, lightweight, secure… yes as developers we want containerization!

Docker and Docker Compose

The word "Docker" refers to several things including an open source project, tools and a company (Docker Inc., the company that primarily supports the project and tools).

Talking about the tools, Docker is a tool designed to make it easier to create, deploy, and run applications by using containers.

Container orchestration automates the deployment, management, scaling, and networking of containers. It can help you deploy the same application across different environments without needing to redesign it. As an example, microservices in containers make it easy to orchestrate services, including storage, networking, and security. Docker Compose is an orchestration tool for Docker containers. [2]

Installing Docker

Mac: https://docs.docker.com/docker-for-mac/install/
Windows: https://docs.docker.com/docker-for-windows/install/
Ubuntu: https://docs.docker.com/engine/install/ubuntu/
Others: https://docs.docker.com/engine/install/

Sails containerization

Now, how do we make Sails, our beloved Node framework, run inside a container?

Sails CLI image

Our container needs an image to run. Let's create one.
To do so, create docker-sails-cli directory and a file named Dockerfile inside it with this content:

FROM node:lts

RUN npm install -g sails@1.4.2

The FROM statement declares we are using node latest lts version as base image for ours. The syntax used is imageName:tag, if no tag is specified, the default is used. [3]

At the same time Node lts image is based on Debian Streatch. So this is our project environment, Sails 1.4.2, node 14.15.4 (at the time of writing this) running on a Debian Streatch.

Now we need to build our image.

docker build . -t sails-cli:1.4.2

Simple, right?

Let’s see what we did.

docker build [context] -t [tag]

context: The context where we are building. As we are in the same directory as the Dockerfile we use .. And also, there’s no need to specify the file name as Dockerfile is the default one.

tag: It is optional, but we want to tag the image we just built as we are probably going to have many different images with different versions for different projects.

Creating a new Sails project

Once we have our Sails CLI image built we are going to use it to create a new Sails project.

docker run --rm -v `pwd`:/app -w /app sails-cli:1.4.0 sails new sails-docker-example --no-frontend

docker run: Create and run a new container
--rm: Remove container after process finishes as we don’t need the container after that
-v: Mount current working directory (in our host computer) in /app path inside container. As a result we are sharing current directory with the container
-w: Set container current working directory to /app
sails-cli:1.4.0: Our previously built Sails image

sails new sails-docker-example --no-frontend: Sails CLI command we want to run in the container.

As a result, after running sails new in the container, we are going to find a new directory created with our new Sails project.

Now, let’s run our project:

cd sails-docker-example
docker run --rm -it -v `pwd`:/app -w /app -p 1337:1337 sails-cli:1.4.0 sails lift

-i: Keep STDIN open even if not attached
-t: Allocate a pseudo-TTY
-p: Maps container 1337 to host computer so we can reach our app through localhost:1337

It's alive!

Running and debugging

As you may notice, although our project is running, if you modify a file you will need to stop the container and launch it again to get the changes applied.

Nodemon to the rescue!

docker run --rm -v `pwd`:/app -w /app sails-cli:1.4.0 npm install nodemon --save-dev

Now, open package.json and in the scripts section add a new one, debug:

"scripts": {
    "debug": "nodemon --inspect=0.0.0.0 app.js",
    "start": "NODE_ENV=production node app.js",
...

And run again, but this time instead of sails lift we are going to run with npm:

docker run --rm -v `pwd`:/app -w /app -p 1337:1337 -p 9229:9229 sails-cli:1.4.0 npm run debug

Now, modify a file, save it and verify that the project is restarted automatically.

Finally, as we are running inside a container we need a way to get the debugger connected to the process, so we are mapping the 9559 port.

If you use VS Code you can use the following configuration in the
launch.json file:

{
    "version": "0.2.0",
    "configurations": [
        {
            "address": "localhost",
            "localRoot": "${workspaceFolder}",
            "name": "Attach to Remote",
            "port": 9229,
            "remoteRoot": "/app",
            "request": "attach",
            "skipFiles": [
                "<node_internals>/**"
            ],
            "type": "node",
            "restart": true
        }
    ]
}

Docker compose

As we mentioned before Docker Compose is an orchestration tool. Compose allows us to define our infrastructure, let’s say, services, networks, volumes in an YAML file.

As a first step we will create a very simple file defining our Sails service on it. For this service we will set image, command, ports mapping, volume mounts, working directory, etc, as we did with Docker command line tool.

Our docker-compose.yml:

version: '3'

services:
    api:
        image: sails-cli:1.4.0 # same as with docker cli
        # Run npm install before starting sails to keep our dependencies installed and updated
        command: sh -c "npm install && npm run debug"
        working_dir: /app # same as -w with docker cli
        ports: # same as -p with docker cli
            - '1337:1337'
            - '9229:9229'
        volumes: # same as -v with docker cli
            - .:/app

Then, we will use docker-compose command to lift our service.

docker-compose up

The result is the same as running with Docker CLI.

In case we want to remove the created infrastructure, once stopped, run:

docker-compose down

This will remove all the containers, networks, volumes created with docker-compose up.

Database containerization

In most cases we will require a database for our project. In this example we will be using MongoDB but it’s possible to do the same with other db engine supported by Sails. [4]

For those who don’t know, MongoDB is a free and open-source cross-platform document-oriented database program. [5]

Fortunately MongoDB has an official image that we will be using to add a database service to our project.

First, we need to add Sails MongoDB adapter to our project. As we did before, we can add and install a dependency to our project with Docker like this:

docker run --rm -v `pwd`:/app -w /app sails-cli:1.4.0 npm install sails-mongo

Then, modify our project config and set mongo as our default adapter.

In the config/datastore.js file:

.
.
.

default: {
    adapter: require('sails-mongo'),
    url: process.env.DB_URL
},

Next we need to add MongoDB service to our docker-compose.yml and provision Sails service with needed config.

docker-compose.yml

version: '3'

services:
    api:
        image: sails-cli:1.4.0
        command: sh -c "npm install && npm run debug"
        working_dir: /app
        ports:
            - '1337:1337'
            - '9229:9229'
        volumes:
            - .:/app
        env_file:
          - ./sails.env # set env vars using a file

    db:
        container_name: mongodb # set name to the container
        image: mongo:4.4 # as of this writing, the latest version is 4.4.3
        volumes:
            - ./mongo:/data/db

We added a db service to our compose file, and also set an env file to Sails service. We will use that file to config our database connection.

sails.env

DB_URL=mongodb://root:@mongodb:27017/sails

Compose allows us to connect to db using the container name as network address, that is why we can use mongodb as the address in our connection url.

Important note: we are not enabling MongoDB authentication for this example but it is a good idea to do so for production environments. [6]

Finally, use docker-compose up to run, you will see MongoDB output along with Sails.

And we are done, a fully Sails development environment running on Docker!

Thank you so much for reading my post, comments are welcome!

Here is the link to the writter's twitter @vidueirof for any questions you may have.

[1] https://www.docker.com/resources/what-container
[2] https://www.docker.com/why-docker
[3] https://hub.docker.com/_/node
[4] https://sailsjs.com/documentation/concepts/extending-sails/adapters/available-adapters
[5] https://www.mongodb.com
[6] https://hub.docker.com/_/mongo

Improve your performance with Scrum Methodology

Euda — Fri, 24 Jan 2020 17:00:54 +0000

Learn how to incorporate this agile methodology to enhance your work performance. Here are some popular tools and recommendations for integrating agile philosophies' elements into your work.

Scrum methodology can help either large or small teams to achieve their work goals, satisfy their clients and develop a better team relationship. But, how?

First of all, let's review what Scrum is.

Born for software development, Scrum is a framework within which people can address complex adaptive problems, while productively and creatively delivering products of the highest possible value. This means, usable and worthy products, in which progress is acknowledgeable. Scrum employs an iterative, incremental approach to optimize predictability and control risk. Three pillars uphold every implementation of empirical process control: transparency, inspection, and adaptation.

How does it work? Easy. You probably already apply scrum philosophy on your work with small differences or by calling it with different names. It's all about organizing work based in the previously specified objectives or goals. Two Scrum elements you can easily incorporate into your work management are:

Defining a Product Backlog: these are the objectives and scope of the product or service to be developed. What you want to achieve, based on the budget and customer needs.

Organizing work into Sprints: each of the phases of the project where the advances are presented to the client. This proves it as it is and suggests changes. These receive a priority according to their importance, and become urgent or are assigned to a second backlog. Dividing the product into sprints will help you reach the desired product through recurring iterations.

Another important part of the Scrum Methodology are team members and their roles. The Scrum Team is divided into three parts:

Product Owner: is the person who knows the business best and decides what improvement or task has to be done in each sprint. It is the channel between managers, investors, clients and development team. Being the person who knows the market and the product best, he/she is the one who makes the final decision.

Development Team: it is recommended to be integrated between 3 and 9 members. It has to be a multifunctional team with defined internal roles required to get the job done (Frontend developers, Backend developers, QA). The interesting thing about this team is its self-management. They themselves decide the work done in each sprint (based on the priorities defined by the Product Owner), and they themselves decide how to perform each of the tasks. It is a team work, without hierarchies.

Scrum Master: being a process that comes out of the ordinary, it is normal that there is resistance from the company or from the Scrum Team members themselves. This is where the Scrum Master comes in, to ensure that everyone follows the process correctly, gives continuous coaching when there is a blockage and eliminate any impediments that arise throughout the sprint.

Depending on the size of your company and team members you can easily adapt each role and its functions. For instance, maybe in small teams Scrum Master and Product Owner tasks can be handled by a Project Manager.

It's essential that all employees are aware of the adopted methodology and its advantages. Giving a workshop explaining how it works and how your company will put it into practice is a great starting point. This may be a very important first task for the designated Scrum Master.

Also, meetings are crucial. Depending on the team size, meetings can be daily, weekly, or one per sprint. It's a matter of trying what's best for each team. However, it is highly recommended to share individual progress within the team on a daily basis. These are two of the Scrum meetings to get inspired by or try implementing:

Sprint Review: is held at the end of the Sprint to inspect the Increment and adapt the Product Backlog if needed. During the Sprint Review, the Scrum Team and stakeholders collaborate about what was done in the Sprint.

Sprint Retrospective: is an opportunity for the Scrum Team to inspect itself and create a plan for improvements to be enacted during the next Sprint. Often occurs after the Sprint Review and prior to the next Sprint Planning.

Moreover, to start improving your performance, any agile methodology requires of some basic tools in order to get an effective comunication between team members and get the work done. Here are some of the most popular ones:

Trello, Jira: get a better project control with a Trello or Jira board, organizing board columns based in the Kanban Methodology: organize work into Backlog, Doing and Done. This way, each card is a task to do, running or finished, helping the team know at a glance the project status and pending tasks. Kanban is widely used within the Scrum methodology, although it also works outside it independently. You may also add more columns, for other stages such as QA, In review and even one for each sprint.

Jenkins: a type of open source software, Continuous Integration oriented. This allows to approach different goals such as early feedback, avoiding merge hell, enabling merciless refactoring among a team and ensuring working software.

Git: another very standardized software to use agile methodology in programming. Besides the benefits of flexibility and distribution, there are key functions of Git that support and enhance agile development. Changes can get pushed down the deployment pipeline faster than working with monolithic releases and centralized version control systems.

Hope you found this useful! Do not wait and start getting great results by incorporating some elements of this agile methodology in your projects.

Source:

...

More about Eudaimonia: https://www.eudaimonia.com.ar