When you become infrastructure

A reflection on the importance of maintaining the open-source projects that become the infrastructure for many companies.

Connecting App Signal with Incident.io using Cloudflare Workers

In this blog post I share how we used Cloudflare Workers to connect AppSignal with Incident.io.

Standards, standards, standards

Proprietary solutions are a dime a dozen, but standards will outlast them all.

Thoughts on Open-Source

In this post, I share my thoughts on open source and how it aligns with my principles. I also talk about the different models that I've seen in the industry and how I'd like to see it evolve.

Transitioning Tuist Cloud from Ruby to Elixir

Ruby proved not to be the most suitable runtime for apps that are IO-heavy. We evaluated Swift, but ultimately decided on Elixir for various reasons.

Elixir scales better

In this blog post, I talk about the scaling challenges we faced with Rails, and why we decided to transition to Elixir.

Gain back attention

In this post, I reflect on how the digital world has hijacked my attention and what I'm doing to gain it back.

If I could just parallelize my tests execution

Schemes in Xcode have an option to run tests in parallel, but if your code isn't designed for it, you are in for a world of pain.

On protecting my creative energy

In this post, I share my thoughts on protecting my creative energy and how I'm doing it.

Global state is future debt

In this post, I share my thoughts on global state and how it's future debt.

It takes a lot of determination

The world needs more people who are determined to make a difference. In this post, I share my thoughts on the importance of determination and how it has helped me in my life.

It's not about what, but how

In this post, I share my thoughts on the challenges of building something new and how it's important to focus on the 'how' rather than the 'what.'

JavaScript DX without JavaScript

In this post, I explore the idea of having a platform-agnostic and technology-agnostic compiler that can be plugged in as an in-code backend for rendering purposes in any other stack (Rails, Phoenix, Express).

Incremental Xcode workflows across environments

Xcode struggles to achieve incremental builds within the same environment. What about across environments? Not even close. Tuist is working on bringing incremental builds and test execution to Xcode projects across environments.

AirPods Max died after 2 years

Apple might have found a legal loophole to charge users for hardware issues caused by software updates.

Xcode is too magic

Xcode is a great tool for beginners, but it makes it hard for developers to understand what's going on under the hood and optimize their workflows.

XCBundles

Xcode doesn't have a native container for bundling resources for different platforms and architectures. But nothing stops us from creating our own for Tuist.

Gifting OSS

Navigating the dynamics of Open Source Software (OSS) and sustainability in the tech industry.

Global state, CLIs, and test scalability

In this post, I talk about how global state in CLIs can make your test suite flaky and how to solve it to scale your test suite.

Deterministic tool versions across environments with Mise

Non-deterministic tool versions across environments is a common source of headaches in development teams. In this post, I share how Mise can help you solve it.

I'm allergic to complexities

I like understanding complexities to simplify them. In this post, I share some examples of complexities that I'm intentionally avoiding because they are complex and therefore not fun.

Starting therapy next week

2023 was a year of many challenges in my life. Next week I'm going to start mental therapy with a psychologist.

Open-source and the imposter syndrome

In this post, I talk about how I'm feeling about my contributions to the open-source community.

I'm sick

Cieza, my hometown, is a beautiful place, but it's also a toxic environment that makes me sick. In this post, I reflect on my connection with this city and the Spanish culture.

Type safety but at which cost?

Type safety, while important, can be overrated and lead to over-engineering. In this post, I share my thoughts on the topic.

JavaScript-owned state and accessibility

WAI-ARIA attributes are a great layer to persist application state and make the website accessible. However, the convenience of JavaScript APIs to store state makes them store all the state in JavaScript, making the websites less accessible.

What if XCTest a concept akin to Elixir's processes?

Erlang processes are a powerful concept that allows you to mock dependencies without introducing dependency injection. In this post, I share my thoughts on how XCTest could adopt a similar concept.

Learning to love the problem and not the solution

We engineers are vulnerable to getting attached to solutions instead of problems. In this post, I share my experience with this and how I'm trying to change it.

Implicitness in Xcode and SPM. Why Apple?

Apple embraced implicitness in some areas of the build system, and it's causing headaches to developers. In this post, I share my thoughts on the topic and how we are planning to address it in Tuist.

What I expect from a knowledge management app

In this post, I share what I expect from a knowledge management app.

Swift Packages default to supporting all platforms

Swift Package Manager defaults to supporting all platforms when they don't specify any. This is a problem for tooling like Tuist that integrates Swift Packages as Xcode project targets.

Swinging back to positivity

2023 was a year full of micro-traumas that led me to a negative mindset. In this blog post, I talk about how I'm working on swinging back to positivity.

Open-sourcing the lightning_css Elixir package

In this blog post I talk about the motivations that led me to build and open-source lightning_css, an Elixir package to bring a more advanced CSS bundler to Elixir and Phoenix projects.

On mental health

In this blog post I open myself about recent mental breakdowns and how I'm dealing with them.

3 package managers + 2 build tools = One big mess

I shared a bit of a reflection on what are the issues with current Apple's tooling touching on some of the points that I presented in my Swiftable 2023 talk.

Peeling layers

This blog post contains a recent reflection over the often over-abstracted web platform, and how powerful it's become, making many of the normalized abstractions feel unnecessary.

Ensuring a smooth workshop experience

In preparation for a workshop that I'm conducting in Swiftable (Buenos Aires), I came up with an idea to ensure a smooth experience following the workshop

Balancing mastery and sustainability

Juggling roles in Tuist, from coding to community support, taught the delicate balance between mastery and sustainability in open-source projects.

Dear Bitrise

Read my personal take on Bitrise's actions against Tuist, and how we're rallying as a community to uphold our values and vision.

Integrating Swift Macros with Xcodeproj native blocks

Exploring native Swift macro support in Tuist to simplify and accelerate Xcode project builds.

Making Tuist easier to work with by saying goodbye to Ruby

We're removing Ruby from Tuist, integrating everything into Xcode, replacing Fourier with bash scripts, and rewriting tests in Swift for ease.

From side project to sustainable tool

Tuist, now 6 years old, has become essential for organizations using Xcode. While initially a side project, its popularity surged. To ensure sustainability, we're introducing paid features alongside free ones, navigating challenges like unauthorized forks and finding the right business model.

Empowering Development: The Journey and Vision of Tuist

Tuist provides solutions to challenges in large-scale app development overlooked by Apple. It's a foundation for developers, promising simplicity and a future filled with actionable insights.

Recalibrating Mental Models in Elixir Programming

Navigating through Elixir requires a rethinking of traditional OOP mental models, inviting a shift towards domain-centric thinking. Embracing Elixir's functional paradigm offers intriguing challenges and a rewarding, fresh perspective on problem-solving in programming.

We do it for the community

Embarking on a nuanced journey with Tuist, facing ethical dilemmas & aiming for sustainability, I invite you to be part of our personal tech story.

Between Simplicity and Limitations: A Developer's Take on Apple's Tooling Strategy

Apple's focus on simplifying basic tasks may overshadow the challenges of complex operations. Developers, often uninformed due to lack of data, face hard choices: pivot to alternatives or revamp systems.

Reclaiming Mental Peace: My Personal Odyssey

Battling daily mental fatigue, I embarked on a personal journey to rediscover clarity. Through exercise, mindful task management, and self-reflection, I'm finding my way back.

Exploring Mocking Solutions in Elixir: Introducing Modulex

Exploring Elixir's Mox for mocking reveals boilerplate code issues. A new package, modulex, aims to streamline this process.

Passion vs. Profit: My Quest for Meaningful Craftsmanship in Tech

In a world where money often takes the front seat, how do we balance the joy of craftsmanship with the need for financial stability? Here's a personal reflection on the intersection of passion, craft, and monetary pursuits.

Tuist: From Passion to Craftsmanship, Charting New Horizons

From its inception in 2018, Tuist has grown through passion and dedication, now embarking on new horizons.

Fixing request/2 is undefined or private with Ueberauth

Tackled 'request/2 undefined' error in Ueberauth setup for Digestfully, sharing solution here.

Abstracted complexity remains complexity

Recently, I had to decide on a technology stack for Glossia, a localization tool I’m bootstrapping with my wife. Choosing a technology stack is an exciting decision for us, as software crafters. Still, it carries a profound impact on both the software and the business that builds on it, and should not be taken lightly.

The Power of Concurrency: My Journey Learning Elixir

Exploring Elixir, I discovered the power of concurrency-oriented programming

Fixing psych compilation error trying to install Ruby on an Apple M2 laptop

Buckle up for a hilarious adventure in Ruby installation! Unravel the mysteries of rtx, Homebrew, and secret environment variables.

An update on the entrepreneurship path

Embarking on a tech-venture adventure; creating value, chasing joy, and conquering challenges.

Integrating Tailwind into your Swift projects

Tailwind: A game-changer for web styling, with seamless integration into Swift server projects using SwiftyTailwind.

Issues Dockerizing a Vapor project in M2

Fly CLI + Docker on M1/M2 architecture caused issues, so I switched to GitHub Actions for deployment. No more problem!

Focusing on Swift

Transitioning from Swift to diverse technologies broadened my problem-solving skills, but scattered focus hindered productivity. To prioritize mental well-being, I'll limit tech consumption. Swift and Apple's ecosystem captivate me, offering integrated tools and a supportive community for app development. I'll step back from web-related learning and return to my roots, enjoying the process of building apps once again.

Hitting memory limits deploying Vapor apps to Fly

Deploying a Vapor app to Fly encountered unexpected issues. Swift's linter requires more memory than Fly's 2048 MB limit. Scaling via fly scale didn't solve the problem. Workaround: built locally with Docker, then pushed to Fly's image registry for deployment.

Embracing the Journey of an Indie Developer

After 5 years at Shopify, I’ve decided to pursue solopreneurship. Drawing on my craftsmanship and software development skills, I’ll build and sell tools based on user needs. Excited for the intimate relationship with development and greater agency over my life. Open to insights from others on this journey.

How to Configure VSCode to Use Alternative Shells

Learn how to easily configure VSCode to use your preferred alternative shell installation like ZSH or Fish instead of the default profiles.

Generating client secret from Apple's P8 key in Elixir

Implementing Sign in with Apple on a macOS app using JWT and Phoenix. Learn how to generate a client secret for web authentication.

Typescript not loading in Visual Studio Code

I share the investigation into Visual Studio Code not loading Typescript and the solution I found - enabling the @builtin typescript extension.

Iterating on my learning system

Some notes on what changes I'm introducing to my learning system.

Static imports with ESM and startup time

When building a Command-line interface (CLI) with Javascript and

An explicit build graph with Nx for a better DX

When I started doing Javascript more actively, something that got my attention was the absence of a build system that allowed declaring a build graph explicitly. Most of the time, developers combin...

Hot-reloading and ESM

While building Gestalt, I realized that many web frameworks don’t move away from CommonJS because the...

Growing as a Staff Developer

A couple of months ago, I reached Shopify‘s Senior Staff Developer level. They were exciting news and excellent proof that Shopify continues to be a place for grow...

Typing file-system paths in Typescript

Learn about an NPM package that we published recently, typed-file-system-path, that adds primitives to work with file-system paths more safely using types.

On learning Elixir

As you might have noticed, I’ve been learning Elixir for the past few weeks. Why? You might wonder. I’m a programming languages nerd. I like learning about ho...

On finding passion in devising developer experiences

What am I professionally? I don’t have a clear answer. I used to say I was an iOS developer with a passion for Swift, but that’s n...

Modular projects, Typescript, and developer experience

Have you tried to set up a modular Typescript project with multiple NPM packages? It’s painful. Typescript tried to solve that with

On embracing my chaos

Over the past few years, I’ve tried and failed many times at giving my chaotic self some order — something that inevitably made me feel anxious. I tried to organize myself ...

Mitigating 'delete node_modules'

If you’ve worked in the Javascript ecosystem, you might already be familiar with the “delete node_modules” solution commonly suggested on StackOverflow...

But they are developers too

I often hear a statement when justifying decisions in building developer tools: but they are developers too. It bugs me a ton because it throws all the developers into the same bag and assumes that...

CLIs are products too

Over the years of working on command-line interface tools I observed that they are not often perceived as products. Consequently, ...

Javascript, ESM, and tools

I’m using Javascript, Typescript, and Node a lot these days as part of my work at Shopify and Gestalt and I’m really loving i...

Users don't care about your web app's portable binary

We, software crafters, naturally tend to distance ourselves from users led by excitement for technological cycles and innovation. Our industry is full of examples. For instance, th...

OSS and extrinsic motivators

More and more, we see open-source projects being backed by investment rounds. It’s positive for the projects because they can innovate faster and sustain themselves by paying peopl...

Platform-dependent CLIs

I’m a firm believer that shaping products as developer platforms is an amazing idea to let developers from all over the world make your product diverse. Otherwise, you have product...

On evolving opinions

I recently came across a tweet that suggested me to undo my blog post on Web3 after sharing some bad things I’d uncovered in the technology. I couldn’t unde...

Migrated to SvelteKit

I migrated this blog to SvelteKit. I did it to consolidate everything I had learned about the framework, and be able to SSR static pages with dynamic content. ...

Adapting to a platform

In a simplistic way, we can see web frameworks as convenient functions that take your app as input and return deployable artifacts. GatsbyJS...

I want to be rich

The React chain

I’ve been thinking a lot lately about the role React plays when building a web app. Companies like GitHub and

On cutting off some dopamine dependency

Over time, my relationship with the Internet has turned me into a dopamine-dependent. I’ve reached a point when my body often has a physical presence in the offline world throughout the day, but my...

Great solutions for the wrong problems

As you might know, I’m a curious person. That leads me to reading about challenges tech companies run into and the solutions that they come up with, and connecting them with similar problems with t...

Developer platforms and diversity

If we think about how tech companies build products these days, we’ll realize many present a single model that they push onto the world. Companies like

Spain, it's not time to be reunited (yet)

As some of you might know, we’ve been in Barcelona looking for a flat to relocate from Berlin for the past few weeks. A few things happened during the COVID19 pandemic that prompted us to think abo...

A future note to self about Omniauth

Every time I try to set up Omniauth on a Rails codebase I run into the same issue: Not found. Authentication passthru ...

./dev

One of the things that I appreciate as a developer is having a consistent experience across projects. As you probably know, this is often not the case when running a project locall...

Seabolt support for M1

As part of building Chimera, an AppleOS tool for capturing networked knowledge, thoughts, and ideas, I encountered an issue trying to set up

Some Rust thoughts

A while ago, I started reading about the Rust programming language out of curiosity. Many things fascinated me about the language. It has a powerful dependency manager similar to the Swift Package ...

Planning open-source work

One of the things that I find the hardest when building open-source software is planning the work. On one side, there are all these new features and improvements that you’d like to...

Contributors' first experience

When building open-source software, getting external contributions is usually one of the most difficult things. Most of the times developers are busy working on their projects, and they are hesitan...

What I learned as a manager

As you might know, Shopify allowed me to try the people management track and become an engineering manager. I’ve been doing that for the past two years. Along the ...

Propose, prototype, and build

One of the things I like about Shopify is an internal tool called Vault. It’s the backbone of the organization. You can find people, navigate the ...

Back to Jekyll

I recently changed my stand in regards to the technologies that I use when building software. In particular, I decided to minimize the amount of Javascript that I use in my project...

Swinging the pendulum back to engineering

Over the past two years, I’ve been engineering manager at Shopify. I managed the Mobile Tooling and React Native Foundations teams over here. I’m grateful that Sho...

Focused Xcode projects

A while ago, and inspired by Facebook’s internal tooling, we added a new command to Tuist, tuist focus. As it names says, it’s intended to be used when you want to work ...

On not having focus

One of the things that I struggle a lot with these days is focus. Because of that, I realized I cannot longer do deep and focused work. I spend my days context-switching all the ti...

Tuist 2.0 and next

As we are approaching the release of Tuist 2.0, I started thinking what’s next for the project. The focus until 1.0 was around project generation. We provided developers with a graph-based project ...

Building mental models

As you probably know, I started building Buildify, an open-source and AGPL-3-based tool for deployments. Like I did with Tuis...

ViteJS and Rails

I recently had to set up a React frontend for a Rails app, and I decided to use ViteJS instead of Webpack. What’s ...

Learning Rust

I became weirdly excited for Rust lately. It’s a programming language that I’ve been planning to learn for some time and I finally set out to learn it. It’s just the beginning of my learnin...

Migrating documentation to Docusaurus

Writing a project’s documentation is not as exciting as coding, but over the years I got to understand the key role of documentation in the developer experience. Shopify for instance has a team ded...

TailwindCSS or Theme-UI

I’ve been using TailwindCSS a lot lately. I like the fact that styles are contained within the HTML elements through classes. You can copy and paste an element styled with Tailwind and you can be c...

Community-driven and organization-driven open source

Yesterday, while reading about Rust and its package manager, Cargo, I realized how diverse the list of Crates (packages...

The role of flexibility in scaling up Xcode projects

I often wonder why Apple continues to build features that are closed into Xcode, for example Swift Package Manager’s integration. While some developers might see that as something positive, because...

Open source, people, and happiness

When looked from the consumer standpoint, open source often reads as software publicly available that I can check out, use, and improve. However, there’s more than that. In a world where everyone s...

Data-driven open source

Yesterday, we announced that Tuist has now stats that allows us to understand how users use the tool and therefore, invest our time working on Tuist more wisely...

Building Tuist as a platform

Having seen Shopify acting as an e-commerce platform that developers can extend made me think whether the same idea would be applicable to Tuist. What if instead of us trying to codify all differen...

Tuist and JS bundlers

I think there are a lot of similarities between Tuist and JS bundlers. First, they both are functions that take input and return an output. In the case of a JS bundler, it takes Javascript or any v...

Owning your workflows

The more I work with Javascript and Ruby, the more I realize how empowering it is to design your workflows. Having worked with Xcode and Swift for many years, I was used to Apple dictating your wor...

Focusing on the problems

One of the things that I noticed when building tools for developers, either through Tuist or my work at Shopify, is that we developers tend to get incredibly excited about what our new idea would e...

Tuist and the Swift Package Manager

It’s common to see developers wondering why they should use Tuist instead of the Swift Package Manager (SPM) for modeling their projects. I think it’s normal. It happ...

Tackling technical debt in Tuist

I’ve recently spent a lot of time in Tuist tackling technical debt. It’d been a while since the last time I have to pause some other work for weeks to do something th...

Decision records

One of the things I’ve been terrible at is at keeping decisions records in projects. It happens often working on Tuist that I come across something that I need to know why it was d...

Scaling up an open-source project

One thing that I’ve been struggling a lot with lately is the amount of distractions that come with the growth of an open-source project. In the case of Tuist, those d...

The beauty of a standard command line interface

There’s something beautiful in entering a directory that contains a project and knowing how to interact with it. It’s like being part of a communication where the terminal is the channel and you bo...

Reflecting on 3 years at Shopify

A few days ago, it was my 3rd anniversary at Shopify, and I’ve got the idea of sharing in a short blog post what are the things that I like from Shopify and that allowed me to grow: - ...

My first RFC in the React Native project

Today I created an RFC for the first time in the repository 🥳. I’ve pondering a bunch of ideas for a lon...

My tech stack in 2020

I’m a bit reflective today; I guess because we are approaching the end of this so-odd year. Therefore, I’d like to share what has been my preferred tech stack in 2020 and what most likely continue ...

Sparking joy working with Xcode

I learned by working with Ruby and Ruby on Rails during my time at Shopify that using tools and programming languages that spark joy is crucial for developers’ motivation. Even though we developers...

Tree-shaking Xcode projects

Tree-shaking is a concept inspired by Javascript and used by Tuist to generate lean Xcode projects that are processed and compile faster.

Module caching in Xcode projects

Bazel and Buck is the solution large companies have adopted to make Xcode build fast. However, it's complex and not accessible to medium and small companies. In this blog post, I share the approach Tuist is taking and how it's inspired by tools the community is already using.

Growing Tuist's community

In this blog post, I share my experience building the Tuist community. I talked about the things that have worked well, and the areas where there's still some room for improvement.

The exciting adventure of building a web app

I’ve been playing lately with building a web app that complements Tuist with some features that require storing state in a server. Since I have a mobile development b...

Generating Typescript code from a GraphQL schema

Today, I learned about a tool called GraphQL Code Generator turns a GraphQL schema into typed models and utilities for interacting with a GraphQL A...

What I like from Ruby and Rails

The more I use Ruby and Rails, the more I like it. I’ve played with Typescript lately, and it continues to feel heavy: parenthesis and brackets eve...

Modularization in open source projects

I recently came across a blog post from Shopify where they share how they are componentize the main Rails application into smaller pieces with clearly defined boundaries and loose coupling between ...

Finding focus

One of the things that I struggle a lot with these days is having focus. Despite my several attempts to mitigate distractions, they always find their way to make it into my attenti...

Pairing sessions to introduce people to Tuist and open-source

I recently started having pairing sessions with developers interested in contributing to open-source; it’s something that usually intimidates people, but that becomes easier if someone guides you t...

Thinking in terms of problems

One of the things that I find the most challenging these days when building tools for developers is thinking in terms of problems. Very often Tuist’s users ask for features...

The beauty of not expecting something in return

Yesterday I had a thought-provoking chat with an acquaintance. He thinks that when we connect with someone is because they are a means to achieve goals - for example a business par...

A shift towards product development

Working on building tools for developers has helped me realize that what I like even more than coding is going through the product thinking process. That’s why I’m so engaged building

Transitive React Native dependencies

Today I learned about how dependencies are organized by NPM and Yarn. Let’s say we have the following scenario of dependencies: - A -> B -> C (3.2.1)...

Streamlining app development

One thing that I noticed after Shopify‘s commitment to React Native is that it foster a culture of turning ideas into mobile...

WWDC's FOMO

I’m avoiding opening Twitter these days. It makes me a bit anxious receiving WWDC news through people racing to be the first one to publish the cli...

First thoughts on Sorbet

We started using Sorbet to add types to Galaxy’s codebase. Types are great to catch type-related issues statically, a...

Working on new features or tackling technical debt

One of the things that I find the hardest when working on Tuist these days is finding a good balance between adding new features and tackling technical debt. The most...

Add and remove footer using NSBox

If you use macOS, you have probably realized many apps have the following UI component on their settings:

My first coding video on Youtube

I never thought I’d end up doing this, but today I just recorded an uploaded a video to Youtube that is meant to be the first of a series about Tuist. I recorded myse...

To build, or not to build

These days I’m a rollercoaster of emotions ― I guess as a result of COVID19 and spending so much time at home. In particular, these days I’m thinking a lot about Tuist

Cognitive overhead

Bootstrapping and publishing an app to the App Store is not a straightforward process. I tried to do it myself yesterday and a lazy me got stuck when I had to create signing artifacts, write automa...

Graphed knowledge

Most of the note-taking apps that we can find out there are designed around the same organization principle: notes are linearly organized and grouped into higher-lever abstractions that are fol...

Catching crashes at launch time on Android React Native apps

One thing that I noticed about React Native is that with the setup that most teams have on CI launch-time crashes can go unnoticed. Those crashes often happen when the contract bet...

Control and innovation

I saw a tweet this morning where the author was hoping for Apple to announce a new product in the domain of CI. Apple a...

Anxiety-free working

I feel it really hard to work these days without feeling anxious. A Slack ping here, an interesting tweet there, some emails to answer, articles to read that are piling up… With that set up, not on...

Keeping it simple

If there’s something that characterizes my approach to problem solving these days is simplicity. Working on acquiring a product mind-set in the last 2 years has helped me realize h...

Diving into Nix

At Shopify, the dev-infra team has been working on using Nix from one of our internal tools, dev. ...

We need more crafters

I think the technology industry needs more crafters. People that have a genuine and lasting love for what they do. Our industry is filling with people that are constantly t...

A better signing experience in Xcode

A few days ago, Marek decided to take on a proposal that I made for Tuist a while ago, management of certificates and provisioning profiles

From iOS engineer to a T-profiled techie

One of the things that excited me the most about the opportunity to join Shopify back in 2018 was the opportunity to grow and learn from the challenges and the tal...

Generation of Swift interfaces to access resources

Many of you might already be familiar with SwiftGen; a tool that generates Swift code to access resources in a type-safe manner. Having a type-saf...

A standard CLI for Xcode projects

There’s an idea that I’d love Tuist to move towards: provide a CLI that is standard across all the projects defined using Tuist. This is not a new idea; we can see it...

Evolving Tuist's architecture

I’m flying back from Tokyo and took the opportunity to code a bit on Tuist. Since I don’t have Internet connection to get distracted with, I decided to work on something that doesn’t require Intern...

Seeking inmutability

I recently opened up this PR on Tuist that turns models that represent the projects into structs. For some reason, which I don’t remember, I ha...

Social anxiety

I keep falling into the same trap over and over: believing that I should be active in social media to be connected to others and have a prosper professional future. My relationship with them is a r...

Wrapping up 2019

Following every year’s tradition, I’m writing a wrap-up post for this year, 2019. 2019 has been the year when María José and I got married. I proposed to her in January and...

Signing with Xcode on CI

Today, I worked on automating the release process of Angle on CI. At first, I thought it’d be a straightforward task, but it turned out not to be so. Most Xcode proj...

Moving Pods to Packages

Today, I decided to move all Angle‘s dependencies that were defined as CocoaPods Pods to Swift Packages. It was my first-hand exp...

Adding bits of reactive programming to Tuist

In this blog post I talk about a recent decision that we made to start using reactive programming to model asynchronous tasks in Tuist.

Working on a new website for Tuist

An update on what I'm up to these days with Tuist. In particular, I talk about the new website that I'm designing and implementing for the project.

Creating experiences

Picked up my phone and dumped some thoughts on why I'm so engaged and excited to build Tuist.

I am X

This is a short reflection around something that it's common in our industry, professionals labelling themselves and limiting their area of influence.

Module caching with Galaxy

Tuist has been of a great value for developers that found it difficult to extend their Xcode projects because Xcode exposed a lot of complexity to them. Having conceptually compressed those difficulties by leveraging project generation, it's time for Tuist to tackle a new challenge, reduce compilation times.

Static site generators

In this blog post I talk about what traits I expect a static site generator to have, and why I believe Gatsby is a more suitable option than other alternatives in the industry.

Better relative paths

We are providing a new API from Tuist to define relative paths and this blog post describes the motivation behind it and the solution that we are adopting.

Project description helpers

In this blog post I talk about a beautiful abstraction which Alex and I came up with to push Tuist's awesomeness even further.

Abstractions

In this blog post I talk about abstractions in the Xcode projects domain and how Tuist leverages the concept to conceptually compress intricacies of Xcode projects that developers are often confronted with.

Keeping up with dependencies updates

A brief reflection on Dependabot, a tool that was recently acquired by GitHub and that helps automate the process of updating dependencies on your GitHub repositories.

What's coming to Tuist

A Monday blog post with some reflections about the current state of Tuist and its future.

A period of changes

Dumping some thoughts on what the last month have been for me in my personal and professional life.

Project generation

This blog post describes the advantages of dynamic over static Xcode projects, and how Tuist leverages project generation to help teams overcome the challenges associated to scaling up projects.

Adding error tracking to a CLI written in Swift

Trying to add error tracking to Tuist, I realized how the process is not very straightforward. This blog post describes the process that I followed to help other Swift developers add error tracking to their CLI tools.

Derived Info.plist files

In this mini-post I talk about some recent work that I've done in Tuist to support defining Info.plist files in the manifest file.

Running system tasks with Swift and Foundation

In this blog post, I talk about my experience using one of Foundation's APIs, Process.

All you need is tools (talk)

This post contains the video of the talk that I gave at AltConf about why I think it's important investing into tooling and some tips to build great tools.

How I feel working on Tuist

A random reflection about Tuist and why I'm so glad working on it.

The tale of Xcode projects' complexity

This is a short story of how Xcode projects can end up being very complex and hard to maintain.

The urge to be the first

Just an observation of a trend that I've seen in our industry: developers rushing to be the gain the label of expert in a given technology.

Speaking at AltConf

A brief post talking about my experience speaking at AltConf 2019 in San Jose.

Abstracting Info.plist files

On this blog post I talk about an idea that I'm pondering for Tuist. In the aim of abstracting implementation details from Xcode projects, I think there's an opportunity for Tuist to abstract `Info.plist` files which are barely modified by developers after they get created.

T-shaped engineers

Specialized engineers usually refrain from working on tasks outside their comfort zone of familiar programming languages and tools. While I believe this might be a good setup for projects that are just starting, I think building teams with t-shaped engineers is crucial for the long-term success of the project.

Xcode updates are fun

On this blog post I talk about Xcode updates and how painful they can sometimes be.

Reliably installing Xcode

I started developing a tool, install-xcode that aims to help developers to install and upgrade versions of Xcode easily. In this blog post I talk about the motivation behinds building it and some design principles that I'm embrazcing.

macOS development and being comfortable

I've been avoiding macOS development for no reason. This blog post is a short reflection on why I think I've been doing it.

Interacting with Xcode projects in Swift

This blog post is an introduction to the format of Xcode projects and xcodeproj, a Swift library that helps read and update Xcode projects in Swift. The post contains a few hands-on examples for developers to experiment with the library.

Open source and trust

Trust is key for open source projects to thrive. In this blog post I explain what trust has meant for Tuist.

Automated tests for a Swift CLI tool with Cucumber

In this post, I explain how we are able introduce changes and release new versions of Tuist with the confidence of not introducing bugs or breaking things.

Software and people

A reflection on what's one of the most important things to me when building software, the people that make it possible.

Turning negativism into positivism

Short reflection on how beneficial it can be turning negativism into something positive.

Deep linking into macOS apps

Some comments on what's the state of art of macOS handling deeplinks.

GitHub as an organization hub

With the recent GitHub announcement of personal projects, I'm considering using GitHub as a todo platform where I can not only keep track of work-related tasks, but also personal ones. In this brief blog post I talk about how I used to organize myself, and why I think GitHub projects might suit my needs well.

The motivations behind building Tuist

Tuist is my most beloved open source project. In this blog post I touch on the motivations that led me to build it.

Wrapping up 2018 📦

A retrospective on what 2018 has been

All you need is tools 🛠

In this post I talk about why investing in good tooling is crucial for projects to move steadily.

What a psychologist helped me realize

It's been a few months going through a therapy that has helped me understand how my brain works and where the stress that I used to experience came from.

GitHub workspaces using email

With this simple tweak I managed to have a notifications-free GitHub dashboard with workspaces right on my email.

Open source mindfulness

Not being mindful when contributing and maintaining open source projects might lead to burnout or low self-steem. In this blog post I talk about some principles that I applied to have a healthier relationship with the open source.

Why am I obsessed with developers being productive using Xcode?

In the last months I've been investing a big chunk of my free time on building tools to make developers productive working with Xcode. In this blog post I reflect on what led me to start working on that tool, Tuist, and how I'm addressing some of the challenges that are presented when using Xcode at scale.

Open Source

In this blog post I talk about why I work on open source projects and what are the most important elements for me when starting an open source community.

On having focus

I'm struggling to have focus nowadays. In this post I describe why it's so hard for me to focus, and the things that I'm doing to overcome the problem.

Hallo Ruby, wie geht's?

It's been a long time since the last time I coded something on Ruby. In this blog post I talk about why I started using it again, and how it feels after spending a few years working with a compiled language like Swift.

Thoughtful usage of technology

I gave up using Medium and here are the reasons that led me to make the decission.

I gave up using Medium

I gave up using Medium and here are the reasons that led me to make the decission.

The hermeticism and rigidity of Xcode and its projects

Xcode and its projects are not as flexible as they could be, which makes it hard for companies to optimize their workflows and processes. In this post I'll analyze some of the things that I would improve from its build system and projects.

This app could not be installed at this time

Because sometimes Xcode cannot install your apps, and you have to figure out why.

Random thoughts a Friday night in Ottawa

I sat down after work and thought about some things that have been in my mind for some time. I wrote them in this blog post that if I have to summarize it, it talks about minimalism, open source, egno, and career paths.

Wrapping up 2017 📦

A retrospective on what 2017 has been

Linting your Xcode projects with xclint

In this post I talk about a tool I've been working on that allows you to check the state of your Xcode projects, finding missing references and duplicated files.

Consistent vs convenient

I analyze in this post why some decisions that we make in our projects might turn into bad viruses that spread all over the code base.

Modular Xcode projects

This post presents some elementary concepts of how Xcode projects are structured, and introduces an structural approach to build modular Xcode apps.

Providing mocks and testing data from your frameworks.

This post introduces an approach to share testing data and mocks from your frameworks to other frameworks that might need them for testing purposes.

Conditionally embed your dynamic frameworks

A command line tool written in Swift for copying the frameworks from your project to the output frameworks directory.

Little tweak to be more productive writing XCTest tests

Because readability might compromise productivity.

Introducing xcodeproj

Read, update and write your Xcode projects from Swift

Moving back to Berlin

A brief retrospective on what my life has been in the last few months and my thougts on my move to Berlin.

Composable UIs

Build UIs based on reusable components that you can compose in more complex hierarchies.

Divide and conquer

How modularizing your apps is helping us to scale our Xcode app.

📦 Wrapping up 2016

The year is almost over. In this post I summarize everything that happened this year and my new year resolutions.

Extensions, dependency injection and frameworks

Learn how handy protocol extensions can be, when used in a frameworks architecture.

Developing tools for developers

Learnings from being a core developer and providing other teams with the tools that they need for their daily work.

Stepping off the social world

I became addicted to social networks. What’s addicted for me? Opening apps like Facebook, Twitter and

Be Reactive my friend

Article that explains the benefits of reactive programming in the iOS world.

Micro Features Architecture for iOS

Organize your app in small features that you

Network Testing - Say hello to Szimpla

Introduction post for the last library that I've been working on, Szimpla.

A journey into Frameworks - Le Testing Framework

One of posts that tells about the migration from a monolithic architecture based in single target to have multiple reusable Frameworks.

Being disconnected in a connected world

In a world where social networks are moving relationships to the Internet people is becoming more disconnected.

Boy Scouts rule with Danger

Post where I explain how Danger helped us at SoundCloud to apply the programming Boy Scouts rule to our workflow

Automating iOS review tasks with Danger

Post that explains how to automate review tasks with the help of the tool Danger

Marcheta en la vida

Mi experiencia de haber salido a vivir fuera de España y las lecciones aprendidas

Xcode scripts to rule them all

Set of normalized scripts very useful for Xcode projects. Individual contributors will be familiar with them after they clone the project.

States - The source of truth

Overview of states in iOS apps, how we tipically handle them, current challenges with states and how to overcome them

Install the last Carthage version on CI services (Travis, Circle, ...)

Very simple script to keep your Carthage version updated without depending on Brew.

Rewriting SugarRecord, 2.0

I explain in this post how was the process of rewriting SugarRecord, a CoreData/Realm wrapper for Swift.

Functional is about functions (Swift)

Quick introduction to what Functional Programming in Swift is from the simple perspective of functions

Implementing a Mutable Collection Property for ReactiveCocoa

These are the steps I followed to create a Mutable Collection Property for ReactiveCocoa. Very useful if you want to get events about changes produced in a collection

Programación Reactiva en Swift: Parte 1, Introducción

Con la llegada de Swift y la introducción de interesantes operadores, conceptos funcionales, y la seguridad de tipos el paradigma de programación reactiva ha cobrado especial importancia en el desa...

Paginated API requests using Functional Reactive in Swift

Reactive is magic, transform your API responses into streams of data and you'll se how easy is to build for example paginated API requests

Why Open Source helps you to become a better developer

Most of developers haven't tried creating an Open Source component before. Since I apply it to every of my projects I feel the results and development process has improved a lot. In this article I will describe why it's so important

My first Apple Watch impressions

After a day using Apple Watch I would like to share my impressions with the new Apple toy and why I wouldn’t buy the first version

Full control in your hybrid mobile apps with a local server, 8fit

Custom solution to have full control over your hybrid apps bundling the content locally and controlling updates

Modularize your mobile projects

Learn how to split your app components in different bundles instead of dealing with an unique bundle that packages the whole app

Boosting your mobile app with Javascript and some mobile knowledge

Learn how useful might be giving some steps on mobile (Android/iOS) launching mobile solutions with web knowledge and with the same mobile native experience as any other app

Swift and Objective-C playing together

Start using Swift in your Objective-C projects. Avoid some headaches with these useful tips and advices for the communication layer between your Objective-C code base and your future Swift implementations

Codemotion experience

After two days of Codemotion I would like to share my experience in my first time in a developers event like that one

VIPER, Looking for the perfect architecture

Talk I gave in the Redbooth HQ office for NSBarcelona with the iOS team talking about the VIPER architecture

Github as your project management tool

Github is a powerful Git platform commonly used between the developers community. It offers features like issues, labels, milestones, releases, that used properly might help you to manage not only your technical repos but different aspects around your project like design, ideas, ...

Leaving Redbooth

I took de decision to leave Redbooth and join to a new adventure. I explain here the reasons, everything I learned from there and my expectations for 8fit

Setup your iOS Projects for testing

Learn how to setup your iOS for testing using the most popular testing libraries and how to integrate your project tests in the development flow.