🇺🇸 English · 🇧🇷 Português

A personal monorepo for experimentation, prototyping & continuous learning.

codelabs is my personal workspace for exploring technologies, testing ideas & understanding how software works under the hood.

Rather than a collection of polished portfolio projects, this repository serves as a hands-on laboratory for learning through implementation.

Each experiment investigates a concept, explores a technology, tests an approach or compares different solutions to a problem.

These experiments are knowledge drafts: small, focused explorations that prioritize understanding over completeness.

Some may evolve into more substantial applications; others may remain isolated proofs of concept.

Both outcomes are valuable.

• Summary
• Topics
• Structure
• Current Focus
• Philosophy
• Final Notes

The repository is organized by programming language, development domain & area of experimentation rather than around a single application or architectural pattern.

Its current structure includes:

• Bash: introductory examples covering variables & conditional execution.

• JavaScript / Node.js: backend experiments involving runtime fundamentals, CommonJS, HTTP servers and database integrations.

• Express: framework-based implementations covering routing, CORS, database access & authentication.

• Shared resources: reusable types, database schemas, server configuration and HTTP request collections.

• Testing: Jest configuration & Supertest-based backend tests.

• Tooling: TypeScript configuration and a shell script for generating a file tree.

The organization allows experiments to remain independent while supporting shared code where reuse provides a practical benefit.

The repository explores different aspects of software development, including:

• Programming languages, runtimes & built-in APIs.

• Backend development and server-side architectures.

• HTTP servers, routing, middleware & API design.

• Frameworks, libraries and native integrations.

• Database schemas, persistence & data access.

• SQLite and Supabase integrations.

• Authentication, JWTs & password hashing.

• JavaScript module systems and TypeScript configuration.

• Shared modules, dependency organization & project structure.

• Automated testing and development tooling.

• Alternative implementations of similar problems.

• Shell scripting & command-line fundamentals.

These topics represent areas of investigation rather than a fixed roadmap.

New experiments may introduce other languages, frameworks & tools as new questions arise.

The repository's top-level organization separates experiments by language & development domain.

codelabs/
├── languages/
│   ├── bash/
│   │   └── intro/
│   │       ├── conditions.sh
│   │       └── variables.sh
│   └── js/
│       ├── backend/
│       │   └── node/
│       │       ├── README.md
│       │       ├── concepts/
│       │       ├── frameworks/
│       │       └── shared/
│       ├── tests/
│       │   └── jest/
│       │       └── backend/
│       │           └── supertest/
│       ├── jest.config.ts
│       └── tsconfig.json
├── scripts/
│   └── filetree.sh
└── README.md

The tree above highlights the main entry points.

Individual experiment directories contain their own implementations, configuration & supporting resources.

Location: languages/bash/

Introductory shell scripting experiments covering:

• variables.sh — variable fundamentals.

• conditions.sh — conditional execution.

These examples provide a foundation for exploring shell syntax, scripting practices and command-line automation.

Location: languages/js/backend/node/

The Node.js workspace focuses on backend development with JavaScript & TypeScript.

Its structure separates lower-level runtime experiments from framework-specific implementations and shared resources.

Explorations of Node.js fundamentals & built-in capabilities, organized under concepts/commonjs/.

Current areas include:

• Database access: native SQLite & Supabase integrations.

• Operating system APIs: experiments using the Node.js os module.

• HTTP servers: basic server implementations & route handling.

• CommonJS: module organization and runtime-level concepts.

These experiments help isolate underlying mechanisms from framework abstractions, making their behavior & trade-offs easier to understand.

Framework-oriented implementations currently focus on Express with CommonJS.

The directory contains experiments covering:

• Server fundamentals: basic applications & server entry points.

• HTTP behavior: routing and CORS configuration.

• Database integration: native SQLite implementations.

• Authentication: JWT-based flows, bcrypt password hashing & SQLite-backed authentication.

Separating framework implementations from runtime concepts makes it easier to compare higher-level abstractions with lower-level approaches.

Location: languages/js/backend/node/shared/

Reusable resources for related experiments, including:

• Authentication types & database schemas.

• SQLite schemas and Supabase database integration.

• Shared database types.

• Server configuration.

• HTTP request collections for manual API exploration.

Shared resources are introduced when they help maintain consistency or reduce meaningful duplication.

They are not mandatory dependencies for every experiment.

Location: languages/js/tests/

The testing workspace contains Jest backend tests built with Supertest.

Current tests cover Express implementations involving:

• Basic server behavior.
• HTTP route handling.
• Native SQLite database integration.

The testing structure provides a dedicated space for exploring endpoint verification, integration testing & automated validation of server behavior.

The Jest configuration is located at languages/js/jest.config.ts, alongside the TypeScript configuration at languages/js/tsconfig.json.

Location: scripts/

The filetree.sh script supports repository inspection by generating a directory-tree representation.

This small utility complements the repository's exploratory workflow by making its organization easier to inspect & document.

Individual experiments may contain source files, database schemas, HTTP request examples, tests & other supporting resources, depending on their scope.

Their internal structures remain deliberately flexible.

Ex.:

A small runtime demonstration may require only one source file, while an API experiment may involve application & server entry points, routing, database access, environment configuration and automated tests.

Dependencies & configuration can be scoped to individual experiments when necessary.

This preserves their independence and makes alternative implementations easier to compare without introducing unnecessary coupling.

The primary focus is backend development with Node.js and TypeScript, with an emphasis on understanding both the fundamentals of server-side development & the abstractions provided by frameworks.

Current areas of exploration include:

• Node.js runtime behavior, built-in APIs & CommonJS.

• HTTP servers, request handling and routing.

• Express applications, middleware & CORS.

• Native SQLite and Supabase integrations.

• Database schemas, persistence & data access.

• JWT-based authentication and bcrypt password hashing.

• TypeScript types, declarations & compiler configuration.

• Shared modules and dependency organization.

• Automated testing with Jest & Supertest.

• Bash variables and conditional execution.

These areas reflect the current contents of the repository, not a permanent scope.

The focus may evolve as existing experiments develop & new learning objectives emerge.

The guiding principle behind codelabs is simple: learn by building.

I use this repository to:

• Explore unfamiliar concepts through practical implementations.

• Break complex systems into smaller, understandable experiments.

• Compare alternative solutions & architectural approaches.

• Investigate runtime behavior, APIs, dependencies and tooling.

• Understand the trade-offs between simplicity, abstraction, maintainability & flexibility.

• Test ideas in isolation before introducing them into larger projects.

• Preserve useful findings for future reference.

Each experiment should have a learning objective, even when that objective is simply answering a question or observing how a mechanism behaves.

The code does not always need to be elegant, complete or production-ready.

Some experiments prioritize simplicity; others deliberately investigate a particular design decision or expose limitations in an initial approach.

The primary goal is understanding.

codelabs is a work in progress.

Its code, dependencies, conventions, documentation & directory structure may change as experiments evolve and my understanding improves.

Some explorations may remain incomplete or never progress beyond a proof of concept; others may be refactored, replaced, combined or expanded into more substantial implementations.

That is intentional.

Not every experiment needs to become a finished application & not every implementation needs to be reusable.

The scope of each experiment is determined by the question it aims to answer.

Understanding why an approach works, why it fails, what trade-offs it introduces or how it compares with an alternative is a worthwhile outcome in itself.

🇧🇷 Português · 🇺🇸 English

Um monorepo pessoal para experimentação, prototipagem e aprendizado contínuo.

O codelabs é meu espaço pessoal para explorar tecnologias, testar ideias e compreender como o software funciona por baixo dos panos.

Em vez de reunir apenas projetos de portfólio finalizados, este repositório funciona como um laboratório prático de aprendizado por meio da implementação.

Cada experimento investiga um conceito, explora uma tecnologia, testa uma abordagem ou compara diferentes soluções para um problema.

Esses experimentos são rascunhos de conhecimento (knowledge drafts): explorações pequenas e focadas que priorizam a compreensão em vez da completude.

Alguns podem evoluir para aplicações mais elaboradas; outros podem permanecer como provas de conceito isoladas.

Ambos os resultados são válidos.

• Descrição
• Tópicos
• Estrutura
• Foco Atual
• Filosofia
• Observações Finais

O repositório é organizado por linguagem de programação, domínio de desenvolvimento e área de experimentação, em vez de seguir a estrutura de uma única aplicação ou padrão arquitetural.

Sua estrutura atual inclui:

• Bash: exemplos introdutórios sobre variáveis e execução condicional.

• JavaScript / Node.js: experimentos de backend envolvendo fundamentos do ambiente de execução (runtime), CommonJS, servidores HTTP e integrações com bancos de dados.

• Express: implementações baseadas em framework envolvendo roteamento, CORS, acesso a dados e autenticação.

• Recursos compartilhados: tipos reutilizáveis, esquemas de banco de dados, configuração de servidores e coleções de requisições HTTP.

• Testes: configuração do Jest e testes de backend com Supertest.

• Ferramentas: configuração do TypeScript e um script de shell para gerar a árvore de diretórios.

Essa organização permite que os experimentos permaneçam independentes, ao mesmo tempo que possibilita o compartilhamento de código quando a reutilização oferece benefícios práticos.

O repositório explora diferentes aspectos do desenvolvimento de software, incluindo:

• Linguagens de programação, runtimes e APIs nativas.

• Desenvolvimento de backend e arquiteturas do lado do servidor.

• Servidores HTTP, roteamento, middlewares e design de APIs.

• Frameworks, bibliotecas e integrações nativas.

• Esquemas de banco de dados, persistência e acesso a dados.

• Integrações com SQLite e Supabase.

• Autenticação, JWTs e hashing de senhas.

• Sistemas de módulos do JavaScript e configuração do TypeScript.

• Módulos compartilhados, organização de dependências e estrutura de projetos.

• Testes automatizados e ferramentas de desenvolvimento.

• Implementações alternativas para problemas semelhantes.

• Shell scripting e fundamentos da linha de comando.

Esses tópicos representam áreas de investigação, não um roteiro fixo.

Novos experimentos poderão incorporar outras linguagens, frameworks e ferramentas conforme novas perguntas surgirem.

A organização principal separa os experimentos por linguagem e domínio de desenvolvimento.

codelabs/
├── languages/
│   ├── bash/
│   │   └── intro/
│   │       ├── conditions.sh
│   │       └── variables.sh
│   └── js/
│       ├── backend/
│       │   └── node/
│       │       ├── README.md
│       │       ├── concepts/
│       │       ├── frameworks/
│       │       └── shared/
│       ├── tests/
│       │   └── jest/
│       │       └── backend/
│       │           └── supertest/
│       ├── jest.config.ts
│       └── tsconfig.json
├── scripts/
│   └── filetree.sh
└── README.md

A árvore acima destaca os principais pontos de entrada.

Os diretórios de cada experimento contêm suas próprias implementações, configurações e recursos de apoio.

Localização: languages/bash/

Experimentos introdutórios de shell scripting que abordam:

• variables.sh — fundamentos de variáveis.

• conditions.sh — execução condicional.

Esses exemplos fornecem uma base para explorar a sintaxe do shell, práticas de scripting e automação pela linha de comando.

Localização: languages/js/backend/node/

O espaço dedicado ao Node.js concentra-se no desenvolvimento de backend com JavaScript e TypeScript.

Sua estrutura separa experimentos de nível mais baixo, implementações específicas de frameworks e recursos compartilhados.

Explorações dos fundamentos do Node.js e de seus recursos nativos, organizadas em concepts/commonjs/.

As áreas atuais incluem:

• Acesso a bancos de dados: integrações com SQLite nativo e Supabase.

• APIs do sistema operacional: experimentos com o módulo os do Node.js.

• Servidores HTTP: implementações básicas de servidores e tratamento de rotas.

• CommonJS: organização de módulos e conceitos relacionados ao runtime.

Esses experimentos ajudam a isolar os mecanismos subjacentes das abstrações oferecidas por frameworks, facilitando a compreensão de seu comportamento e de seus custos e benefícios.

As implementações orientadas a frameworks concentram-se atualmente no Express com CommonJS.

O diretório contém experimentos relacionados a:

• Fundamentos de servidores: aplicações básicas e pontos de entrada de servidores.

• Comportamento HTTP: roteamento e configuração de CORS.

• Integração com bancos de dados: implementações com SQLite nativo.

• Autenticação: fluxos baseados em JWT, hashing de senhas com bcrypt e autenticação com persistência em SQLite.

A separação entre implementações baseadas em frameworks e experimentos de runtime facilita a comparação entre abstrações de nível mais alto e abordagens de nível mais baixo.

Localização: languages/js/backend/node/shared/

Recursos reutilizáveis para experimentos relacionados, incluindo:

• Tipos de autenticação e esquemas de banco de dados.

• Esquemas SQLite e integração com o banco de dados Supabase.

• Tipos compartilhados relacionados a bancos de dados.

• Configuração de servidores.

• Coleções de requisições HTTP para exploração manual de APIs.

Os recursos compartilhados são introduzidos quando ajudam a manter a consistência ou reduzem duplicações relevantes.

Eles não são dependências obrigatórias para todos os experimentos.

Localização: languages/js/tests/

O espaço de testes contém os testes de backend desenvolvidos com Jest + Supertest.

Os testes atuais abrangem implementações Express envolvendo:

• Comportamento básico de servidores.

• Tratamento de rotas HTTP.

• Integração com bancos de dados SQLite nativos.

Essa estrutura oferece um espaço dedicado à verificação de endpoints, aos testes de integração e à validação automatizada do comportamento dos servidores.

A configuração do Jest está em languages/js/jest.config.ts, junto à configuração do TypeScript em languages/js/tsconfig.json.

Localização: scripts/

O script filetree.sh auxilia na inspeção do repositório ao gerar uma representação de sua árvore de diretórios.

Essa ferramenta complementa o fluxo de experimentação, tornando a organização do código mais fácil de inspecionar e documentar.

Cada experimento pode conter arquivos-fonte, esquemas de banco de dados, exemplos de requisições HTTP, testes e outros recursos de apoio, de acordo com seu escopo.

A estrutura interna permanece deliberadamente flexível.

Uma demonstração simples de um recurso do runtime pode exigir apenas um arquivo-fonte, enquanto um experimento com APIs pode envolver pontos de entrada para aplicação e servidor, roteamento, acesso a dados, configuração de ambiente e testes automatizados.

As dependências e configurações podem ser definidas em diretórios específicos quando necessário.

Isso preserva a independência dos experimentos e facilita a comparação entre implementações alternativas, sem introduzir acoplamento desnecessário.

O foco principal é o desenvolvimento de backend com Node.js e TypeScript, com ênfase tanto nos fundamentos do desenvolvimento no lado do servidor quanto nas abstrações oferecidas por frameworks.

As áreas de exploração atuais incluem:

• Comportamento do runtime do Node.js, APIs nativas e CommonJS.

• Servidores HTTP, tratamento de requisições e roteamento.

• Aplicações Express, middlewares e CORS.

• Integrações com SQLite nativo e Supabase.

• Esquemas de banco de dados, persistência e acesso a dados.

• Autenticação baseada em JWT e hashing de senhas com bcrypt.

• Tipos, declarações e configuração do compilador TypeScript.

• Módulos compartilhados e organização de dependências.

• Testes automatizados com Jest e Supertest.

• Variáveis e execução condicional em Bash.

Essas áreas refletem o conteúdo atual do repositório, não um escopo permanente.

O foco poderá evoluir conforme os experimentos existentes avancem e novos objetivos de aprendizado surjam.

O princípio que orienta o codelabs é simples: aprender construindo.

Utilizo este repositório para:

• Explorar conceitos desconhecidos por meio de implementações práticas.

• Dividir sistemas complexos em experimentos menores e compreensíveis.

• Comparar soluções alternativas e abordagens arquiteturais.

• Investigar o comportamento do runtime, APIs, dependências e ferramentas.

• Compreender os custos e benefícios relacionados à simplicidade, abstração, manutenibilidade e flexibilidade.

• Testar ideias isoladamente antes de incorporá-las a projetos maiores.

• Preservar descobertas úteis para consultas futuras.

Cada experimento deve ter um objetivo de aprendizado, mesmo quando esse objetivo consiste apenas em responder a uma pergunta ou observar o comportamento de determinado mecanismo.

O código nem sempre precisa ser elegante, completo ou estar pronto para produção.

Alguns experimentos priorizam a simplicidade; outros investigam deliberadamente uma decisão de design ou revelam limitações de uma abordagem inicial.

O objetivo principal é compreender.

O codelabs está em constante evolução.

Seu código, suas dependências, convenções, documentação e estruturas de diretórios podem mudar conforme os experimentos avançam e meu entendimento se aprofunda.

Algumas explorações podem permanecer incompletas ou nunca ultrapassar a etapa de prova de conceito; outras podem ser refatoradas, substituídas, combinadas ou expandidas em implementações mais elaboradas.

Isso é intencional.

Nem todo experimento precisa se transformar em uma aplicação finalizada, assim como nem toda implementação precisa ser reutilizável.

O escopo de cada experimento é determinado pela pergunta que ele pretende responder.

Compreender por que uma abordagem funciona, por que falha, quais custos e benefícios apresenta ou como se compara a uma alternativa já é, por si só, um resultado válido.

codelabs is about exploration, not perfection.