I'm a happy Dagger user. I use it heavily for GitOps, but I never thought to use it like this.
Definitely joining the Discord server.
309 karma · joined May 24, 2013
Definitely joining the Discord server.
I assume this isn't optimal for a business setup, but for personal projects, I don't miss GitHub Actions at all.
You can use them together. Config files provide configuration to the application. The config file can read environment variables, so you can deploy the same code across different environments, e.g., your local computer, staging, and production.
Then, each environment will provide system-related configuration, e.g., `DATABASE_URL`.
With this setup, the same code will work on each environment.
Now, .env files should live only on your local machine; on any other environment, they should be set differently, not in files.
The .env file is a convenience, but not the only option for environment variables, nowdays you can use 1Password too.
Personal blog with more drafts than published posts.
It's crazy that the best React DX is provided through Vue's community projects.
They didn't do it flashy for this project specifically (like Claude Code, which I don't think is flashy at all) but every single one of their other projects are like this.
- rely on competent people directly under the executive to guess what that means
- after-meetings in which everyone tries to interpret the executive’s feedback
- the executives are busy and hard to get access to
Imagine having a riddle as feedback in which people from different backgrounds and cultures gather to decipher a meaningful direction.
I don't like that executives don't have to put in the effort to communicate their concerns and put pressure on the people who already have the pressure of researching, validating, and presenting the solution.
I'm probably going deeper than I should. Still, if the executive asking the question isn't technical, he could direct the question to the executive who's supposed to have a technical background that earned their position in the company. You know, people making decisions should have an understanding of what they are building/selling.
It's my daily driver so far. I switch between the Claude and Gemini models depending on the type of work I'm doing. When I know exactly what I want, I use Claude. When I'm experimenting and discovering, I use Gemini.
Location: Houston, TX
Remote: Remote, Hybrid, On-site
Willing to relocate: Yes
Technologies: React, TypeScript, Next.js, Python, Node.js, Go, AWS, Linux, PostgreSQL, Kubernetes
Résumé/CV: https://github.com/j0lvera
Email: inbox [at] jolvera.com
I'm looking for a Go, Python, or React position. Most of my expertise is in leading front-end projects, specifically with React.
I've been involved in building teams and modernizing legacy platforms, and most of my work has been with SaaS enterprise applications.
Location: Houston, TX
Remote: Remote, Hybrid, On-site
Willing to relocate: Yes
Technologies: React, TypeScript, Next.js, Python, Node.js, Go, AWS, Linux, PostgreSQL, Kubernetes
Résumé/CV: https://github.com/j0lvera
Email: inbox [at] jolvera.com
I'm looking for a Go (microservices), Python (data engineering), or React position. Most of my expertise is in leading front-end projects, specifically with React.
I've been involved in building teams and modernizing legacy platforms, and most of my work has been with SaaS enterprise applications.
the CTA buttons across the site are inconsistent in shape, form, and color.
the text color in the footer has awful contrast, so it's hard to read.
- assets/ where I drop all markdown documents, images, database dumps, or any file related to the project that shouldn't go into git.
- src/ it's a directory that contains repositories with source code.
edit: format
because a well-configured k8s cluster nullifies the need for this project. also hi!
- I receive my paycheck in my bank account.
- I want to budget $800 for groceries every month.
- I have a credit card with a balance of $250.
- I want to know how much I have left; we will have an account named Left to Budget (LTB).
Let's outline them as accounts:
- Bank Account. It's an Asset and has a balance of $0.
- Groceries "category" Account. It's a Liability and has a balance of $0.
- AMEX Account. It's a Liability and has a balance of $250.
- LTB is my income account. It's a Liability (yeah, I know, but stay with me).
When I receive my $1,000.00 paycheck.
- Debits Bank (ASSET) for $1,000.00
- Credits LTB (LIABILITY) for $1,000.00
Balances:
- Bank (ASSET) $1,000.00
- Groceries (LIABILITY) $0.00
- AMEX (LIABILITY) $250.00
- LTB (LIABILITY) $1,000.00
I budget $800 for Groceries for this month.
- Debits LTB (LIABILITY) for $800.
- Credits Groceries (LIABILITY) for $800.
Balances:
- Bank (ASSET) $1,000.00
- Groceries (LIABILITY) $800.00
- AMEX (LIABILITY) $250.00
- LTB (LIABILITY) $200.00
I go to the grocery store and buy Milk for $50 and Bread for $10.
- Credits Bank (ASSET) for $60.00
- Debits Groceries (LIABILITY) for $60.00
Balances:
- Bank (ASSET) $940.00
- Groceries (LIABILITY) $740.00
- AMEX (LIABILITY) $250.00
- LTB (LIABILITY) $200.00
As of now, I effectively know that:
- I have $940 in my bank, but I only have $200 available to spend (LTB).
- I have $740.00 left to spend on Groceries in my Bank.
- If I wanted to pay my Credit Card (AMEX) in full, I couldn't. Even though I have enough money in my Bank, most of it is already allocated to Groceries. BUT I could adjust my budget, like so:
Adjust my Groceries budget by moving $50 back to my LTB, so I can pay my Credit Card in full this month.
- Debit Groceries (LIABILITY) for $50
- Credit LTB (LIABILITY) for $50
Balances:
- Bank (ASSET) $940.00
- Groceries (LIABILITY) $690.00
- AMEX (LIABILITY) $250.00
- LTB (LIABILITY) $250.00
OK, so now I know that:
- I still have $940.00 in my bank.
- If I wanted to pay my Credit Card I can because I have enough in my LTB category.
- I have $690.00 available to spend in Groceries, because I moved $50.00 away.
Now, let's pay my Credit Card.
- Credit Bank (ASSET) $250.00
- Debit AMEX (LIABILITY) $250.00
Balances:
- Bank (ASSET) $690
- Groceries (LIABILITY) $690.00
- AMEX (LIABILITY) $0.00
- LTB (LIABILITY) $0.00
Now the money I have left in the Bank is for Groceries only. If I wanted to spend on something else, I'd have to either:
- Create a new Category and transfer an amount from Groceries, or
- wait for my next paycheck.
--
We were able to manage all this information with only one bank account, but we successfully managed a small budget.
Double-entry is a concept that's not necessarily applied directly to "physical" accounts. We transfer values between accounts even when the money stays where it is.
> - Zero liabilities is not a reasonable goal for most people.
Zero liabilities is not a goal; it's the direction on whether money balance increases or decreases; it's not tied to the money you have or owe. It's a concept or formula rather than a reality.
> - There's an equity account type also. (Also income and expense accounts.)
Equity and expenses are Assets. Income can be an Asset or a Liability, depending on how you want to represent it. For me, it is a liability because I want it to be 0. Even tho, my income account will have money, its representation of Money Left to Budget will be zero because the accounts that transfer value from it will include savings or investing accounts.
Two types of accounts:
- assets (you want your balance to be more than 0)
- liabilities (you want your balance to be 0)
Two types of entries:
- debits (increase balances of assets, decrease balances of liabilities)
- credits (increase balances of liabilities, decreases balances of liabilities)
Rules:
- A transaction represents a transfer of value between accounts.
- Every transaction must have at least two entries. The balance of all entries the transaction holds should be 0, i.e., balance = debits - credits.
You don't think about money leaving or entering an account before you nail down those definitions. The account representations can be anything that holds a numeric value, not just money.
You can affect more than two accounts by adding additional entries with the condition of keeping the balance to 0.
--
> But this article is not about the whole UI/UX stack.
And this
> It focuses on benefits on what semantic CSS offers. aka "naming things" vs "not naming things".
That's the problem, you are focusing on giving semantic names to classes while giving an inferior UX on your example. If the inferior UX saves me a few KBs on size and a few milliseconds in load time, I'd still prefer good UX.
A fair comparison should be good UX with semantic CSS.
I agree that using Tailwind--without extra effort--will end up with "meaningless" (not really) classes in the HTML.
But semantics should be prioritized in HTML rather than CSS or class names. What's the benefit of having semantic classes when your HTML is inaccessible and unsemantic? e.g., using `a` instead of `button`, `img` with unsemantic alternative text.
The template the author is comparing against (https://spotlight.tailwindui.com/) has better HTML structure, descriptive text and aria labels on buttons, icons and images. This is what the semantic web is about.
You could argue that the author's template loads faster (not for that much honestly) but the UX won't be better.
Tailwind or Bootstrap's (just to provide an additional example) documentation presents accessible and well styled patterns that end users will benefit from.
People complain about the bloat of these frameworks, but they don't make a fair comparison when checking examples for accessibility, responsiveness (mobile experience) and other features that make a great UX and help with SEO (because in the end accessibility is SEO).
We don't use Tailwind directly on your components (unless necessary and for adjustment only, more on this later).
We try to keep Tailwind as an internal implementation detail. The consumer of our components should pass options as `variant="primary"` where `variant: "primary" | "secondary";` BUT it's okay to allow some Tailwind classes for customization on edge cases.
Example (by memory, syntax might be wrong):
import cn from 'classnames';
// Definition
function Button({ fill, isLoading, className }: ButtonProps) {
return (<button className={cn(
'relative',
'inline-flex',
'rounded',
{
'w-full': fill,
'opacity-50': isLoading,
},
className,
)}
>
{children}
</button>
);
// Usage
// Full-width button, with some margin on the left
<Button fill className={"ml-2"} />
// Regular button, with loading state
<Button isLoading />
This is pretty similar to sleep advice, go to bed and wake up at the same time, every day.
I read somewhere that when you do things at the same hour every day your body prepare for the activity. I can't find the link, but might be curious to know if there's any study to back it up.
In the past, we didn't have complex UIs, we did, but we dealt with them differently. For example, in the era of forms and limited Ajax, keeping the DOM synced with the state took a lot of work.
The complexity we see today results from different ideas of how to deal with that _synchronicity_.
Keep in mind that there's no way to do it natively; the only way to do it is to manually keep the state in sync. The complexity we see today results from the abstractions people have created to accomplish that, e.g., jQuery, Sammy, Backbone, Knockout, Angular, Ember, React, Vue, Svelte, etc.
Enterprise and FAANG required optimizations for different reasons, scale, collaboration, distribution, etc. Programmers wanted to use paradigms to represent things and apply optimizations on the web, and JavaScript wasn't enough. So, they created CoffeeScript, Flow, TypeScript, ReasonML, etc. These tools became popular in the FAANG, wrote posts about them, then people of all industries adopted them.
To use all these cool tools, people created bundlers—each with its configurations, patterns, and philosophies—gulp, Rollup, Webpack, etc.
At this point, the web skyrocketed in complexity from the days of HTML, CSS, and JavaScript when one of the complex tasks was to make rounded corners with images and cool layouts with tables. Of course, you can still build complex UI without these tools and use JavaScript alone, but you will end up abstracting your patterns and paradigms into reusable bits.
Additionally, some developers attempt to use as little JavaScript as possible; one great example of a complex UI trying that is https://sourcehut.org.
Great job!