DEV Community: joaofelipefaria

[FR] Design patterns : d'où viennent-ils ?

joaofelipefaria — Mon, 28 Sep 2026 12:06:29 +0000

Une discussion sur les patrons de conception

L'un des sujets qui suscitent le plus de curiosité (et de confusion) chez les personnes qui entrent dans le monde du développement, ce sont les design patterns. Dans cette petite discussion, je vais essayer de clarifier quelques points sur les patrons de conception.

Qu'est-ce qu'un design pattern ?

Les design patterns sont des solutions techniques utilisées pour résoudre des problèmes récurrents du développement logiciel. Parmi les plus connus et les plus cités dans les conversations sur le logiciel, on trouve : Factory, DAO, DTO, Message Outbox et Pub/Sub.

Là où commence la confusion

C'est ici que la confusion commence. Beaucoup de jeunes développeurs, ne connaissant pas l'origine de ces patterns, ne réalisent pas qu'ils viennent de mondes totalement différents. Avant de nous mettre à les définir, comprenons donc les principaux groupes et d'où ils sont issus.

Les patterns GoF : la programmation orientée objet

Les patterns GoF sont des patrons pour la programmation orientée objet. Le nom vient du « Gang of Four » (Erich Gamma, Richard Helm, Ralph Johnson et John Vlissides), auteurs du livre Design Patterns: Elements of Reusable Object-Oriented Software, publié en 1994. Parmi les principaux : Singleton, Factory Method et Observer.

Les JEE BluePrint Patterns : les applications web

Les JEE BluePrint Patterns sont des patrons pour le développement d'applications web d'entreprise. Ils sont nés dans l'écosystème Java EE (anciennement J2EE), à partir du programme Java BluePrints de Sun Microsystems, et ont été catalogués dans le livre Core J2EE Patterns, paru en 2001. Parmi les principaux : DAO, DTO et Front Controller.

Les patterns de messagerie : l'intégration entre systèmes

Les patterns de messagerie traitent de la communication asynchrone et de l'intégration entre systèmes au moyen de messages. Leur référence principale est le livre Enterprise Integration Patterns, de Gregor Hohpe et Bobby Woolf, publié en 2003, et le sujet a pris encore plus d'ampleur avec l'arrivée des microservices. Parmi les principaux : Publish/Subscribe, Dead Letter Channel et Transactional Outbox.

Et il en existe d'autres

Il existe d'autres familles, comme les patterns d'UI/UX, qui portent sur la façon de concevoir les interfaces et les interactions. Deux exemples : le Breadcrumb (fil d'Ariane) et l'Infinite Scroll. Il existe aussi des patterns pour l'IA, des patterns d'architecture, parmi bien d'autres.

Prochaines étapes

Dans les prochains articles, nous approfondirons ces familles de patterns, une par une. Nous définirons les patterns, comprendrons le problème qu'ils résolvent et verrons comment les implémenter dans vos projets.

[EN] Design patterns: where do they come from?

joaofelipefaria — Mon, 28 Sep 2026 12:05:50 +0000

A chat about design patterns

One of the topics I see sparking the most curiosity (and confusion) among people entering the world of software development is design patterns. In this short chat, I'll try to clear up a few things about them.

What are design patterns?

Design patterns are technical solutions used to solve recurring problems in software development. Some of the best known and most frequently mentioned in conversations about software are: Factory, DAO, DTO, Message Outbox and Pub/Sub.

Where the confusion starts

And this is where the confusion begins. Many younger developers, not knowing where these patterns come from, don't realize they originate from completely different worlds. So before we start defining patterns, let's understand the main groups and where they came from.

GoF Patterns: object-oriented programming

GoF Patterns are patterns for object-oriented programming. The name comes from the "Gang of Four" (Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides), the authors of the book Design Patterns: Elements of Reusable Object-Oriented Software, published in 1994. Among the main ones are Singleton, Factory Method and Observer.

JEE BluePrint Patterns: web applications

JEE BluePrint Patterns are patterns for developing enterprise web applications. They came out of the Java EE (formerly J2EE) ecosystem, from Sun Microsystems' Java BluePrints program, and were cataloged in the 2001 book Core J2EE Patterns. Among the main ones are DAO, DTO and Front Controller.

Messaging patterns: integrating systems

Messaging patterns deal with asynchronous communication and integration between systems through messages. Their main reference is the book Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf, published in 2003, and the topic gained even more traction with the rise of microservices. Among the main ones are Publish/Subscribe, Dead Letter Channel and Transactional Outbox.

And there are others

There are other families, such as UI/UX patterns, which deal with how we design interfaces and interactions. Two examples are the Breadcrumb and Infinite Scroll. There are also patterns for AI, architecture patterns, and many others.

Next steps

In the next articles, we'll dive deeper into these pattern families, one by one. We'll define the patterns, understand the problem each one solves, and see how to implement them in your projects.

[PT] Design patterns: de onde eles vêm?

joaofelipefaria — Mon, 28 Sep 2026 12:03:42 +0000

Um bate-papo sobre padrões de projeto

Um dos assuntos que mais vejo despertar a curiosidade (e a confusão) de quem está entrando no mundo do desenvolvimento são os design patterns. Neste pequeno bate-papo, vou tentar esclarecer algumas coisas sobre os padrões de projeto.

O que são design patterns?

Design patterns são soluções de tecnologia usadas para resolver problemas recorrentes do desenvolvimento de software. Alguns dos mais conhecidos e mencionados em conversas sobre software são: Factory, DAO, DTO, Message Outbox e Pub/Sub.

Onde começa a confusão

E aqui começa a confusão. Muitos programadores mais jovens, por não conhecerem a origem desses patterns, não percebem que eles vêm de mundos totalmente diferentes. Por isso, antes de sairmos definindo patterns, vamos entender os principais grupos e de onde eles surgiram.

GoF Patterns: orientação a objetos

Os GoF Patterns são padrões para a programação orientada a objetos. O nome vem da "Gang of Four" (Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides), autores do livro Design Patterns: Elements of Reusable Object-Oriented Software, publicado em 1994. Entre os principais estão Singleton, Factory Method e Observer.

JEE BluePrint Patterns: aplicações web

Os JEE BluePrint Patterns são padrões para o desenvolvimento de aplicações web corporativas. Surgiram no ecossistema Java EE (antigo J2EE), a partir do programa Java BluePrints da Sun Microsystems, e foram catalogados no livro Core J2EE Patterns, de 2001. Entre os principais estão DAO, DTO e Front Controller.

Patterns de mensageria: integração entre sistemas

Os patterns de mensageria tratam da comunicação assíncrona e da integração entre sistemas por meio de mensagens. Sua principal referência é o livro Enterprise Integration Patterns, de Gregor Hohpe e Bobby Woolf, publicado em 2003, e o tema ganhou ainda mais força com a chegada dos microsserviços. Entre os principais estão Publish/Subscribe, Dead Letter Channel e Transactional Outbox.

E ainda existem outros

Há outras famílias, como os patterns de UI/UX, que tratam de como projetamos interfaces e interações. Dois exemplos são o Breadcrumb e o Infinite Scroll. Existem ainda patterns para IA, patterns de arquitetura, dentre diversos outros.

Próximos passos

Nos próximos artigos, vamos nos aprofundar nessas famílias de patterns, uma a uma. Vamos definir os patterns, entender o problema que eles resolvem e ver como implementá-los em seus projetos.

[FR] Java en pratique : classes, objets et packages

joaofelipefaria — Mon, 28 Sep 2026 12:02:11 +0000

Java est orienté objet

Java est un langage orienté objet. Concrètement, cela signifie que l'on construit un programme Java en écrivant des classes et en manipulant des objets. La classe est le moule ; l'objet est l'instance créée à partir de ce moule.

Attributs et méthodes

À l'intérieur d'une classe, les méthodes représentent le comportement d'un objet et les attributs représentent son état. Pour rendre cela concret, modélisons une voiture, qui a une marque et une année de fabrication :

package com.exemple.modele;

public class Voiture {

    String marque;
    int annee;
}

Le package

La première déclaration d'un fichier de classe est le package. Il indique dans quel package se trouve la classe et répond à trois objectifs :

éviter les collisions de noms (deux classes portant le même nom peuvent coexister dans des packages différents) ;
regrouper les classes par responsabilité ;
permettre à d'autres classes de les importer.

Créer et utiliser un objet

Dans cet exemple, en plus de Voiture, nous allons créer une seconde classe nommée Application. Elle importe Voiture et, dans la méthode main, crée une voiture, renseigne la marque ("fiat uno") et l'année (2002), puis affiche ces valeurs :

package com.exemple;

import com.exemple.modele.Voiture;

public class Application {

    public static void main(String[] args) {
        Voiture voiture = new Voiture();
        voiture.marque = "fiat uno";
        voiture.annee = 2002;

        System.out.println("Marque : " + voiture.marque);
        System.out.println("Année : " + voiture.annee);
    }
}

En exécutant Application, la console affiche la marque et l'année de la voiture créée. Remarquez que Application se trouve dans un package différent de celui de Voiture ; elle a donc besoin de l'import pour la voir.

Ce que nous avons appris

Avec ce petit exemple, nous avons déjà vu quelques comportements de base du langage : la déclaration de package, la définition d'une classe avec ses attributs, l'importation de classes et l'instanciation d'un objet avec new.

À propos des types

En utilisant les mots-clés String et int, nous définissons le type de chaque attribut : un texte pour la marque et un nombre entier pour l'année. Java est un langage à typage statique, et cela s'applique aux attributs, aux variables et aux paramètres.

Prochaines étapes

Dans les prochains articles, nous approfondirons le typage en Java et explorerons les syntaxes possibles de la méthode main.

[EN] Java in practice: classes, objects and packages

joaofelipefaria — Mon, 28 Sep 2026 12:01:31 +0000

Java is object-oriented

Java is an object-oriented language. In practice, this means we build a Java program by writing classes and manipulating objects. The class is the blueprint; the object is the instance created from it.

Attributes and methods

Inside a class, methods represent an object's behavior and attributes represent its state. To make this concrete, let's model a car, which has a brand and a year of manufacture:

package com.example.model;

public class Car {

    String brand;
    int year;
}

The package

The first statement in a class file is the package declaration. It tells which package the class belongs to and serves three purposes:

avoiding naming collisions (two classes with the same name can coexist in different packages);
grouping classes by responsibility;
allowing other classes to import them.

Creating and using an object

In this example, besides Car, we'll create a second class called Application. It imports Car and, in the main method, creates a car, sets the brand ("fiat uno") and the year (2002), and finally prints both values:

package com.example;

import com.example.model.Car;

public class Application {

    public static void main(String[] args) {
        Car car = new Car();
        car.brand = "fiat uno";
        car.year = 2002;

        System.out.println("Brand: " + car.brand);
        System.out.println("Year: " + car.year);
    }
}

When you run Application, the console prints the brand and year of the car we created. Note that Application lives in a different package from Car, so it needs the import statement to see it.

What we learned

With this small example we've already seen some basic language behaviors: the package declaration, defining a class with its attributes, importing classes, and instantiating an object with new.

About types

By using the keywords String and int, we define the type of each attribute: text for the brand and a whole number for the year. Java is a statically typed language, and this applies to attributes, variables and parameters.

Next steps

In the next articles, we'll dive deeper into typing in Java and explore the possible syntaxes for the main method.

[PT] Java na prática: classes, objetos e pacotes

joaofelipefaria — Mon, 28 Sep 2026 12:00:08 +0000

Java é orientado a objetos

Java é uma linguagem orientada a objetos. Na prática, isso significa que construímos um programa Java codificando classes e manipulando objetos. A classe é o molde; o objeto é a instância criada a partir dele.

Atributos e métodos

Dentro de uma classe, os métodos representam o comportamento de um objeto, e os atributos representam o seu estado. Para deixar isso concreto, vamos modelar um carro, que tem uma marca e um ano de fabricação:

package com.exemplo.modelo;

public class Carro {

    String marca;
    int ano;
}

O pacote (package)

A primeira declaração de um arquivo de classe é o package. Ele informa em qual pacote a classe está e serve a três propósitos:

evitar colisões de nomes (duas classes com o mesmo nome podem coexistir em pacotes diferentes);
agrupar classes por responsabilidade;
permitir que outras classes as importem.

Criando e usando um objeto

Neste exemplo, além de Carro, vamos criar uma segunda classe chamada Application. Ela importa Carro e, no método main, cria um carro, informa a marca ("fiat uno") e o ano (2002) e, por fim, imprime esses valores:

package com.exemplo;

import com.exemplo.modelo.Carro;

public class Application {

    public static void main(String[] args) {
        Carro carro = new Carro();
        carro.marca = "fiat uno";
        carro.ano = 2002;

        System.out.println("Marca: " + carro.marca);
        System.out.println("Ano: " + carro.ano);
    }
}

Ao executar Application, o console exibe a marca e o ano do carro criado. Repare que Application está em um pacote diferente de Carro, e por isso precisa do import para enxergá-la.

O que aprendemos

Com esse pequeno exemplo, já vimos comportamentos básicos da linguagem: a declaração de pacote, a definição de uma classe com seus atributos, a importação de classes e a instanciação de um objeto com new.

Sobre os tipos

Ao usar as palavras-chave String e int, estamos definindo o tipo de cada atributo: um texto para a marca e um número inteiro para o ano. Java é uma linguagem de tipagem estática, e isso vale para atributos, variáveis e parâmetros.

Próximos passos

Nos próximos artigos, vamos aprofundar a tipagem dentro do Java e explorar as sintaxes possíveis para o método main.

[FR] Java et les fondamentaux de la programmation orientée objet

joaofelipefaria — Tue, 15 Sep 2026 09:31:42 +0000

La programmation orientée objet (POO) est l'un des principaux paradigmes de programmation utilisés avec Java. Plus qu'un simple concept de programmation, elle représente une manière très naturelle pour le cerveau humain d'interagir avec son environnement. Lorsque nous entrons dans une pièce, par exemple, nous identifions naturellement les choses qui présentent des caractéristiques similaires et nous les regroupons mentalement : nous reconnaissons des chaises, des tables, des personnes, des portes, etc. Intuitivement, nous sommes en train de classer les éléments en catégories (classes) et d'identifier leurs occurrences concrètes (objets). La POO utilise précisément cette manière de penser pour représenter le monde réel dans un système informatique, en considérant que les objets possèdent un état et un comportement.

L'histoire de la POO a commencé avant Java lui-même, avec des langages comme Simula et Smalltalk, qui ont contribué à établir plusieurs concepts fondamentaux de ce paradigme. Plus tard, des langages comme C++ et Java ont contribué à populariser la programmation orientée objet dans le développement logiciel.

En Java, une classe fonctionne comme un modèle permettant de créer des objets. Elle définit des attributs, qui représentent l'état de l'objet, et des méthodes, qui représentent son comportement. À partir d'une classe Car, par exemple, nous pouvons créer plusieurs voitures différentes, chacune possédant son propre état.

La création d'un objet se fait généralement avec l'opérateur new, comme dans Car myCar = new Car();. À ce moment-là, nous créons une instance concrète de la classe. Les constructeurs permettent d'initialiser ces objets. Ils portent le même nom que la classe et n'ont pas de type de retour.

Un autre concept important est celui des interfaces, qui fonctionnent comme des contrats de comportement. Une interface peut définir des opérations qu'une classe doit implémenter, permettant ainsi à différents types d'objets de respecter le même contrat. Java possède également des membres static, qui appartiennent à la classe elle-même et non à une instance particulière.

Java propose également les blocs d'initialisation, qui permettent d'exécuter du code lors de l'initialisation d'un objet ou du chargement d'une classe. Même s'ils sont moins utilisés dans le développement quotidien, ils font partie des mécanismes d'initialisation disponibles en Java.

Ces concepts constituent la base nécessaire pour comprendre les principes plus avancés de la POO : encapsulation, héritage, polymorphisme, abstraction et composition. Ils permettent de construire des systèmes mieux organisés, réutilisables et plus faciles à maintenir — et c'est précisément sur ces concepts que nous pouvons poursuivre l'étude de la POO en Java.

[EN] Java and the Fundamentals of Object-Oriented Programming

joaofelipefaria — Tue, 15 Sep 2026 09:31:18 +0000

Object-Oriented Programming (OOP) is one of the main programming paradigms used in Java. More than just a programming concept, it represents a very natural way for the human brain to interact with the environment. When we enter a room, for example, we naturally identify things with similar characteristics and group them mentally: we recognize chairs, tables, people, doors, and so on. Intuitively, we are classifying elements into categories (classes) and identifying their concrete occurrences (objects). OOP uses exactly this way of thinking to represent the real world inside a software system, considering that objects have state and behavior.

The history of OOP began before Java itself, with languages such as Simula and Smalltalk, which helped establish many of the fundamental concepts of the paradigm. Later, languages such as C++ and Java helped popularize object-oriented programming in software development.

In Java, a class works as a blueprint for creating objects. It defines attributes, which represent the object's state, and methods, which represent its behavior. From a Car class, for example, we can create several different cars, each with its own state.

An object is normally created using the new operator, as in Car myCar = new Car();. At this point, we are creating a concrete instance of the class. Constructors are used to initialize these objects and have the same name as the class, with no return type.

Another important concept is the interface, which works as a behavioral contract. An interface can define operations that a class must implement, allowing different types of objects to follow the same contract. Java also provides static members, which belong to the class itself rather than to a specific instance.

Java also has initializer blocks, which allow code to be executed during object initialization or when a class is loaded. Although they are less commonly used in everyday development, they are part of Java's available initialization mechanisms.

These concepts form the foundation for understanding the more advanced principles of OOP: encapsulation, inheritance, polymorphism, abstraction, and composition. Together, they allow us to build systems that are more organized, reusable, and easier to maintain — and these are precisely the concepts we should explore next when studying OOP in Java.

[PT] Java e os fundamentos da Programação Orientada a Objetos

joaofelipefaria — Tue, 15 Sep 2026 09:30:35 +0000

A Programação Orientada a Objetos (POO) é um dos principais paradigmas utilizados no desenvolvimento com Java. Mais do que um conceito de programação, ela representa uma forma bastante natural de o cérebro humano interagir com o ambiente. Quando entramos em uma sala, por exemplo, naturalmente identificamos coisas com características semelhantes e as agrupamos mentalmente: reconhecemos cadeiras, mesas, pessoas, portas etc. Intuitivamente, estamos classificando elementos em categorias (classes) e identificando suas ocorrências concretas (objetos). A POO utiliza justamente essa maneira de pensar para representar o mundo dentro de um sistema, considerando que os objetos possuem estado e comportamento.

A história da POO começou antes do próprio Java, passando por linguagens como Simula e Smalltalk, que ajudaram a estabelecer conceitos fundamentais desse paradigma. Posteriormente, linguagens como C++ e Java popularizaram a orientação a objetos no desenvolvimento de software.

Em Java, uma classe funciona como um modelo para criar objetos. Ela define seus atributos, que representam o estado, e seus métodos, que representam os comportamentos. A partir de uma classe Car, por exemplo, podemos criar vários carros diferentes, cada um com seu próprio estado.

A criação de um objeto é feita normalmente através do operador new, como em Car myCar = new Car();. Nesse momento, estamos criando uma instância concreta da classe. Os construtores são utilizados para inicializar esses objetos e possuem o mesmo nome da classe, não tendo tipo de retorno.

Outro conceito importante são as interfaces, que funcionam como contratos de comportamento. Uma interface pode definir operações que uma classe deve implementar, permitindo que diferentes tipos de objetos sigam o mesmo contrato. Além disso, Java possui membros static, que pertencem à própria classe e não a uma instância específica.

Também existem os initializer blocks, que permitem executar código durante a inicialização de objetos ou durante o carregamento da classe. Embora sejam recursos menos utilizados no dia a dia, fazem parte dos mecanismos de inicialização disponíveis em Java.

Esses conceitos formam a base para compreender os pilares mais avançados da POO: encapsulamento, herança, polimorfismo, abstração e composição. A partir deles, conseguimos construir sistemas mais organizados, reutilizáveis e fáceis de manter — e é justamente sobre esses conceitos que o estudo de POO em Java deve avançar.

[FR] MapData App (un terrain de jeu full-stack)

joaofelipefaria — Sat, 29 Mar 2025 17:42:34 +0000

Bienvenue dans le Projet MapData : Votre Terrain de Jeu Full-Stack !

Salut, développeur ! Prêt à plonger dans un projet qui n'est pas seulement une expérience d'apprentissage, mais aussi un environnement pratique pour le développement full-stack avec Java et Angular ? Laissez-moi vous présenter le Projet MapData, un système modulaire parfait pour gérer les données cartographiques et les métadonnées, tout en vous offrant la flexibilité d'explorer plusieurs frameworks et outils.

Qu'est-ce que le Projet MapData ?

Le Projet MapData est avant tout un environnement de travail de base pour les développeurs full-stack. Il repose sur une architecture de microservices avec une API backend, une application frontend Single Page Application (SPA) et des utilitaires pour gérer la base de données et l'environnement. Que vous soyez un développeur expérimenté ou débutant, ce projet est une excellente opportunité pour explorer les technologies modernes.

Voici ce qui est inclus :

mapdata-api : Une API RESTful pour gérer les données cartographiques et les métadonnées.
mapdata-app : Une application frontend élégante basée sur Angular pour l'interaction utilisateur.
mapdata-db : Gère la création et la maintenance du schéma de la base de données.
mapdata-web : Une version frontend légère utilisant HTML, CSS et JavaScript pur.
mapdata-automations-python : Scripts Python pour automatiser et gérer l'environnement.

Et le meilleur ? Vous pouvez changer les frameworks ! Vous voulez essayer Quarkus au lieu de Spring Boot ? React au lieu de Angular ? Allez-y ! Le projet est conçu pour être flexible.

La Technologie Derrière la Magie

Voici un aperçu rapide :

Java : Le backend est construit avec Java, le langage incontournable pour les applications d'entreprise. Fiable, évolutif et parfaitement intégré avec des frameworks comme Spring Boot ou Quarkus.
Angular : Le frontend SPA est construit avec Angular, un framework puissant pour créer des applications web dynamiques et réactives.
Docker : Tout fonctionne dans des conteneurs, ce qui simplifie le déploiement et la gestion de l'environnement.
Python : Les scripts d'automatisation sont écrits en Python, une langue polyvalente idéale pour les tâches d'automatisation.
JavaScript Pur : Pour ceux qui aiment la simplicité, le composant mapdata-web est une version frontend pure en HTML/JS.

Comment Créer l'API et l'Application

Création de l'API

Clonez le dépôt :

   git clone https://github.com/joaofelipefaria/mapdata.git
   cd mapdata/mapdata-api

Construisez le projet :

   mvn clean install

Lancez l'API :

   java -jar target/mapdata-api-0.0.1-SNAPSHOT.jar

Création de l'Application

Accédez au répertoire de l'application :

   cd mapdata/mapdata-app

Installez les dépendances :

   npm install

Lancez l'application en mode développement :

   ng serve

Accédez à l'application à l'adresse http://localhost:4200.

Et la Base de Données et le Web ?

mapdata-db : Ce composant gère le schéma de la base de données. Configurez simplement le fichier pom.xml et exécutez :

   mvn clean install

Cela créera toutes les tables et séquences nécessaires.

mapdata-web : Vous voulez un frontend simple ? C'est celui qu'il vous faut. Ouvrez simplement le fichier index.html dans votre navigateur, et c'est parti.

Automatisation : Votre Nouveau Meilleur Ami

Gérer les environnements peut être compliqué, mais pas avec mapdata-automations-python. Ces scripts Python vous permettent de démarrer, arrêter et gérer les services Docker facilement. Par exemple :

Démarrez l'environnement :

   python run_env.py

Arrêtez tout :

   python shutdown_env.py

C'est aussi simple que ça. Plus besoin de commandes Docker manuelles !

Prêt à Vous Lancer ?

Le Projet MapData est bien plus qu'un simple projet : c'est un terrain de jeu pour les développeurs full-stack. Que vous construisiez quelque chose de nouveau ou que vous exploriez simplement, c'est l'environnement parfait pour affiner vos compétences. Alors, qu'attendez-vous ? Clonez le dépôt et commencez à coder !

GITHUB

https://github.com/joaofelipefaria/mapdata

MapData App (a full-stack playground)

joaofelipefaria — Sat, 29 Mar 2025 17:36:38 +0000

Welcome to the MapData Project: Your Full-Stack Playground!

Hey there, developer! Are you ready to dive into a project that’s not just a learning experience but also a practical environment for full-stack Java and Angular development? Let me introduce you to the MapData Project, a modular system that’s perfect for managing map data and metadata while giving you the flexibility to explore multiple frameworks and tools.

What’s the MapData Project?

At its core, the MapData Project is a basic work environment for full-stack developers. It’s built around a microservices architecture with a backend API, a frontend Single Page Application (SPA), and utilities to manage the database and environment. Whether you’re a seasoned developer or just starting out, this project is a great way to get your hands dirty with modern tech.

Here’s what’s included:

mapdata-api: A RESTful API built to handle map data and metadata. It’s your backend powerhouse.
mapdata-app: A sleek Angular-based frontend for user interaction.
mapdata-db: Handles database schema creation and maintenance.
mapdata-web: A lightweight frontend using pure HTML, CSS, and Vanilla JavaScript.
mapdata-automations-python: Python scripts to automate and manage the environment.

Oh, and did I mention? You can swap out frameworks! Want to try Quarkus instead of Spring Boot? React instead of Angular? Go for it! The project is designed to be flexible.

The Tech Behind the Magic

Let’s break it down:

Java: The backend is built with Java, the go-to language for enterprise applications. It’s reliable, scalable, and integrates seamlessly with frameworks like Spring Boot or Quarkus.
Angular: The frontend SPA is built with Angular, a powerful framework for creating dynamic, responsive web applications.
Docker: Everything runs in containers, making deployment and environment management a breeze.
Python: The automation scripts are written in Python, a versatile language that’s perfect for scripting and task automation.
Vanilla JavaScript: For those who love simplicity, the mapdata-web component is a pure HTML/JS version of the frontend.

How to Create the API and App

Creating the API

Clone the repository:

   git clone https://github.com/joaofelipefaria/mapdata.git
   cd mapdata/mapdata-api

Build the project:

   mvn clean install

Run the API:

   java -jar target/mapdata-api-0.0.1-SNAPSHOT.jar

Creating the App

Navigate to the app directory:

   cd mapdata/mapdata-app

Install dependencies:

   npm install

Run the app in development mode:

   ng serve

Access the app at http://localhost:4200.

What About the Database and Web?

mapdata-db: This component manages the database schema. Just configure the pom.xml file and run:

   mvn clean install

It’ll create all the necessary tables and sequences for you.

mapdata-web: Want a simple frontend? This is your go-to. Just open the index.html file in your browser, and you’re good to go.

Automations: Your New Best Friend

Managing environments can be a pain, but not with mapdata-automations-python. These Python scripts let you start, stop, and manage Docker services with ease. For example:

Start the environment:

   python run_env.py

Shut everything down:

   python shutdown_env.py

It’s that simple. No more manual Docker commands!

Multiple Framework Choices

One of the coolest things about the MapData Project is its flexibility. Want to try a different backend framework like Quarkus? Or maybe a frontend in React or Flutter? The project is modular, so you can experiment with different tech stacks without breaking a sweat.

Ready to Dive In?

The MapData Project is more than just a project—it’s a playground for full-stack developers. Whether you’re building something new or just exploring, this is the perfect environment to sharpen your skills. So, what are you waiting for? Clone the repo and start coding!

GITHUB

https://github.com/joaofelipefaria/mapdata