I graduated university in 2007. Back then, databases meant one thing: tables, rows, and relationships. A user has orders. Orders have products. Everything is connected, and you draw those connections carefully on a whiteboard (or a notebook) before you write a single line of code.

That’s just how data works, right? Things in the real world are related to each other. It makes sense to model that. Similar how classes in OOP are a natural way to model real-world entities, relational databases felt like the natural way to model real-world data.

Then NoSQL came along. Suddenly, you could just throw data into a big flexible blob without worrying too much about structure or relationships. It was like someone had looked at a filing cabinet and said “what if we just used a pile on the floor instead?”

Maybe that’s my bias showing, or my old age. But I’ve been sitting with this question for a while now: do we actually need NoSQL databases in 2026, or have I just not updated my thinking since 2007?

Let me try to work through it “on-paper” here.

What even is NoSQL?

If you’re not a developer, here’s the short version. A traditional relational database (like PostgreSQL or MySQL) stores data in structured tables, kind of like spreadsheets, and lets you link those tables together. NoSQL is a term for databases that don’t do that. They store data differently, often as flexible documents (imagine JSON files), key-value pairs (like a dictionary), or other formats.

The pitch for NoSQL is roughly: more flexibility, easier to scale to massive amounts of data, no need to define your structure upfront. This “no need to define structure” was a big part of the appeal. Just throw data in and figure out how to use it later.

Where NoSQL makes sense

When speed is everything and the data is simple. Think of things like a leaderboard in a game, user session data, or a cache. You’re not doing complex queries, you just need to store something and retrieve it incredibly fast. Key-value stores like Redis are brilliant at this. A relational database would be overkill.

When your data doesn’t have a fixed shape. Imagine a product catalog where a t-shirt has “size” and “color” attributes, but a laptop has “RAM”, “CPU”, and “screen size”. These are very different. Forcing them into the same table structure is awkward. A document store like MongoDB lets each product just be what it is.

When you’re dealing with enormous scale across multiple regions. Big tech companies (think Amazon, Netflix, or Facebook) have data spread across data centers all over the world. Some NoSQL databases are specifically built to handle that kind of scale, accepting some trade-offs (like the data not being perfectly up-to-date everywhere at all times) to stay fast.

For highly connected data, like social networks. Ironically, one area where NoSQL really shines is relationships, but a specific kind. Graph databases (like Neo4j) are built to answer questions like “who are the friends of my friends who also like jazz?” across millions of people. A relational database can do this, but it gets slow fast.

So yes, there are real use cases. But those use cases are pretty specific. They’re not the kind of thing most apps need.

But here’s where my head still hurts

The thing is, most apps aren’t Netflix. Most apps I’ve worked on, and most apps most developers build, have data that is relational. Users have profiles. Profiles belong to organizations. Organizations have subscriptions. Subscriptions have invoices.

That stuff has relationships. And relational databases were literally invented to model exactly that.

When I look at a NoSQL document store handling that kind of data, I often see one of two things. Either the data ends up duplicated everywhere (the user’s name stored in fifty different places), or the app code ends up doing the work that the database used to do — manually stitching data together, checking consistency, making sure nothing gets out of sync.

That’s not a win. That’s moving complexity from a place designed to handle it (the database) to a place that’s much worse at handling it (your application code, written by humans, at 11pm, day before Black Friday).

Meanwhile, relational databases haven’t been standing still

This is something I think gets missed in the NoSQL conversation. Tools like PostgreSQL have been quietly adding features that close the gap significantly.

For example — PostgreSQL has a column type called jsonb that lets you store flexible, document-like data inside a relational database. So you can have the best of both worlds - structured, relational data where you need it, and flexible blobs where you don't. And all of that in one place, with proper transactions and data integrity guarantees.

Modern relational databases can also handle a lot more scale than people give them credit for. The “NoSQL scales better” argument made a lot of sense in 2010. In 2026, it’s a much more nuanced picture.

The honest downsides of NoSQL

I want to be clear I’m not just being a grumpy old dev here. There are real trade-offs with NoSQL that don’t always get talked about enough.

You lose consistency guarantees. Many NoSQL databases are “eventually consistent,” which means for a short time, different users might see different versions of the data. For some apps that’s fine. For anything involving money or critical records, it can be a serious problem.

You become responsible for your data’s integrity. Relational databases enforce rules. For example, you can’t link an order to a user that doesn’t exist. With many NoSQL databases, that’s your problem now. One bug in your code and you’ve got orphaned, inconsistent data with no safety net.

Flexible schemas are a double-edged sword. Yes, it’s nice to not have to define everything upfront. But six months into a project, when your documents all look slightly different because three developers made different assumptions, you’ll wish someone had drawn a schema on a whiteboard.

Querying can get awkward. SQL (despite its age) is a remarkably powerful and expressive way to ask questions of your data. Equivalent operations in some NoSQL databases require more code, more effort, and sometimes just aren’t possible at all.

So where does that leave me?

Honestly? Still pretty relational in my thinking. And I think I’m okay with that. At least for now, until I get a project that genuinely needs NoSQL’s strengths.

I don’t think my instinct to model data as interconnected things is a limitation from my education. I think it reflects something true about how a lot of real-world data actually works. And relational databases are really good at modeling that.

Does that mean I’d never use NoSQL? No. But I’d want to be very sure I needed it before I went down that path.

My overall take: if you’re building most apps, a well-used PostgreSQL database will take you further than you think, for longer than you think, with fewer surprises than you think. And if you ever genuinely outgrow it, you’ll know. And the NoSQL option will still be there and you’ll be able to migrate your data if needed.

I just wouldn’t start there.

If you like this article consider tweeting or check out my other articles.

Originally published at https://lukapeharda.com.

TL;DR Use EXISTS when querying if SQL records exists instead of using COUNT. EXISTS is much more efficient and breaks out of the loop when first record is found.

Using COUNT

Until recently, when I had to check if a DB record that satisfies some conditions exists, I’ve used a COUNT and then check if returned result is greater than 0.

Plain SQL query:

SELECT COUNT(*)
FROM `post_likes`
WHERE `member_id` = 1
AND `post_id` = 1

MySQL has COUNT(*) optimised and it is faster and more efficient than using COUNT(id) for example.

Laravel Eloquent query (using postLikes relationship):

// Did member like a post
$member->postLikes()->count() > 0;

Notice the brackets after postLikes() relationship name. This means we are using the relationship to generate query on the related table and setting up foreign key for us. If we used $member->postLikes->count() , without the brackets, we would fetch all related records and then do a count afterwards. This would result in a much costlier DB query, and more memory used as all those records needs to saved to memory.

This would “force” a DB to count through all of the records that satisfies these conditions. And if your table is large enough it could take some time. Granted, probably in milliseconds but still it would do unnecessary work as it does not know that you are just interested in “existence” of the record and not the exact count.

Of course, if you indexed the table “properly” and use a composite index on member_id and post_id columns result would be pretty fast in this scenario but in some others it still may be optimised.

Using EXISTS subquery

Better way would be to use an EXISTS subquery. This is available in MySQL from version 5.7 so there is no reason not to use it.

You can check MySQL docs on EXISTS here. There is also NOT EXISTS subquery.

EXISTS works by encapsulating a query in SELECT subquery:

SELECT EXISTS(
 SELECT *
 FROM `post_likes`
 WHERE `member_id` = 1
 AND `post_id` = 1
)

Doesn’t matter if your SELECT fetches all columns (*) or plain 1 , SELECT will be discarded in EXISTS query.

This query will return true if subquery has at least one record or false if there are no records that satisfies your conditions. MySQL will break out of the "loop" when it finds the first record and this is what makes it more performant than the COUNT.

In Laravel you can use exists method on the query builder:

// Did member like a post
$member->postLikes()->exists();

Eloquent will encapsulate the query in the EXISTS subquery.

Eloquent also provides whereExists , whereNotExists , doesntExist, withExists and several more to allow you to build a query that you need.

Proper example of using EXISTS

I’ve been using this to check existence of all kinds of records and relationships. Like permissions, likes and even as a nested subquery.

For example, when fetching a list of posts to display on the page, I want to know if member did like a post in order to show a proper UI icon. This could lead to a N+1 situation where for each post we’d have to do a separate SQL query to check if record exits.

Or we can use EXISTS subquery:

SELECT `id`, `title`, `content`, exists(
 SELECT *
 FROM `post_likes`
 WHERE `posts`.`id` = `post_likes`.`post_id`
 AND `member_id` = 1
) AND `is_liked`
FROM `posts`

This will be done in a single optimised SQL query and provide information if member liked a post in a generated is_liked column. To be precise, MySQL will do N+1 subqueries to check for existence but this will be optimised and done internally.

In Laravel you’d use withExists to do the same thing:

$posts = Post::query()
 ->select(['id', 'title', 'content'])
 ->withExists([
        'postLikes as is_liked' => function ($query) {
      $query->where('member_id', $member->id);
     }
    ]);

is_liked will be added as an attribute on each $post model.

This optimisation may not seem as important and it may look like a “micro” improvement. But if your tables have millions of records then you already know that every millisecond counts.

Originally published at https://lukapeharda.com.

One of the biggest reasons why I moved my blog from Gatsby to Astro was its markdown integration and ease of creating new articles using markdown syntax.

Not only markdown but MDX — using JSX and component imports in markdown content.

Using Tailwind CSS typography plugin

As my blog is built using Tailwind CSS, content for the blog articles were also using Tailwind’s classes to style it. This means that instead of using regular

<p>

tags I’m using

<p class="pb-3 text-slate-400 text-xl">

to create a “simple” paragraph. As you can see this isn’t really simple nor does it enable me to write articles fast.

Not that the speed of converting my thoughts and ideas into HTML markup was my biggest problem.

Sensible person would use Tailwind’s typography plugin to style all content markup using CSS classes on the markdown content parent element. Their page even says that the plugin’S intended use is to to add beautiful typographic defaults to any vanilla HTML you don’t control, like HTML rendered from Markdown.

How would the paragraph look like using Tailwind’s prose classes?

<article class="prose prose-p:pb-3 prose-p:text-slate-400 prose-p:text-xl">

You’d have to add modifiers to the parent element class attribute. And repeat those modifiers for all other “target” like a, h1, h2, ul and all others.

And you’d have to reset some of the defaults that typography plugin brings to the table. It looks less and less as a sensible solution. Right?

Assigning Custom Components to HTML elements

Fortunately smart folks from MDX were already thinking of scenarios like that.

That is why you can import your custom component and then export a components object that maps the standard HTML to your custom component:

import Paragraph from '../components/Paragraph.astro';
export const components = {p: Paragraph}

This will be styled custom paragraph.

Paragraph.astro component is pretty simple:

<p class="pb-3 text-slate-400 text-xl">
    <slot />
</p>

<slot /> is where the "child" content (paragraph's text) will go.

This whole article was written using standard markdown syntax with styling applied by overwritting the HTML with custom components. I must say that the speed of writing this article surprised even me. Whole article was written in VS Code without any need for custom HTML markup nor CSS nor messy copy/pasting from older articles.

Now I’m off to find a good VS Code extension for Grammarly so I literaly don’t have to use any other tool to publish an article.

To learn more, visit Astro’s Markdown Content guide or MDX Website for a full list of HTML elements that can be overwritten as custom components.

Originally published at https://lukapeharda.com.

It has gotten to my attention that one of the biggest dev agencies in the region has a pull-request requirement that checks whether each file committed is under 100 lines long.

It seems like a pretty stupid requirement, right?

Then I tried it.

I had a class that was 133 lines long and I want to see whether I can get it under 100. As the class was already “doing one thing” it didn’t make sense to refactor it and split it into two files.

First to go were the comments 😀 Method docblocks were replaced with proper type declarations and return types. To preserve the readability, variable and method names had to be changed to be self-explanatory although a bit longer. Conditionals were extracted into separate methods.

Multiple simple IFs were combined into one, which did hurt readability a bit but it saved 5 lines 😀

Somewhat duplicated code was extracted and parametrized which allowed me to reuse methods in several locations.

And I got to 99 lines 🚀

I was skeptical about this requirement when I started but now I see its benefits. It makes you think about your code a bit more and forces you to make it more readable while also removing clutter from your files. And as strange as this may sound, it was fun doing it 😆

A friend of mine published a short post, an Instagram post really, called “Six ethics of life” among which was “Before you write, THINK.” In the context of his post, it makes sense. But it still triggered me and got me thinking.

There are a lot of scenarios where writing makes me think clearly and what is more important, more efficiently. And it helps me to structure my thoughts.

Solving coding problems

When I’m stuck on some coding problem or having a hard time debugging an issue I use writing to move everything from my head to make space for thinking and defining a context. Normally I use paper and pencil, but when they aren’t available I use Notion.

I use a process sprawling across a series of steps that guides me to my solution. The process and the steps were influenced by the Feynman Technique of Learning but were heavily modified.

1. First, I succinctly describe the problem, often I posit it as a question. This sets a context for me.
2. Then, similarly to Feynman Technique, I write down the stuff I know and stuff that I’m certain is true. In case of debugging an issue, I write down the consequences of the issue at hand, data (or database) state, and code (classes) involved.
3. I write down the unknowns and things I need to learn more about before making any judgment. And how to convert “unknowns” to “knowns”.
4. Afterward, I move on to possible causes. After listing the most obvious culprits, I try to look outside the box and come up with barely plausible scenarios. For each of the items here I specify how to validate, confirm or discard the idea.
5. After clearing these steps pretty much everything is cleared up and there usually aren’t any big obstacles for developing a solution.

Naturally, sometimes these aren’t enough so additional steps are added to the process.

If the problem at hand is not urgent the I let it simmer for a while and let my unconscious thoughts work on it. I either take a walk, change the working environment (work from a coffee place, work from home), or even sleep on it.

The last step is basically waiting for a solution to strike me in my head :-)

Making decisions

I use a similar process when I’m stuck at deciding which solution or idea to pursue.

One difference is using second-order thinking, especially if I’m dealing with legacy code or working on code I didn’t write (or forgot about). I tend to really worry about Chesterton’s Fence kicking me in the but :-)

The additional benefit of writing down your decision process is that you can easily convert conclusions in your decision diary. You are keeping that, right? How else would you preserve knowledge in your org?

Trends, as well as frameworks, comes and goes. Heck, JavaScript frameworks come and go each day 😂

Fundamentals are forever. So it would be wise to invest your time to grow those.

Although this article is written for software developers, I believe there are some universal truths here everybody can learn from.

Fundamentals

• Teamwork — Great teams build great software so don’t take teamwork and your team for granted. Cultivate and prune your team. And, what is more, try to see situations from a different team member’s perspective.
• Trust and cohesion — “Team without trust isn’t a team: it’s just a group of individuals, working together, often making disappointing progress”. Teams move at the speed of trust. Be the kind of dependable person you would want to work with.
• Communication — Communicate honestly and proactively. Do not assume that because you understand something and it is simple and easy for you that everybody else perceives it the same. Listen before speaking.
• Seek Consensus — It is really helpful if the whole team is on the same page so make sure to take the time for your whole team to get aboard. Discussion and disagreement are not necessarily bad as they can lead you to the best solution.
• Automated Testing — Well-tested code allows you (and your team) to move fast with confidence. And not only that, using TDD (where you write tests simultaneously as you code) can speed up your development by providing faster means of testing (clicking through your UI to test some scenario is tedious, error-prone, and slow).
• Clean, understandable, and navigable code and design — Think of the next engineer that will take over your code as your customer. Build code that your successor won’t have any trouble reading, maintaining, and updating. More often than not you will be your own “customer” and you’ll have to modify some parts several months later and you’ll have trouble navigating your work if not properly taken care of. So imagine how hard this would be for someone else.

Multiplicative System

One extra thing to consider is the multiplicative system mental model.

Let’s say you value your coding skills as “10”, writing clean code as “8”, your testing skills as “9” but your communication skills as “0” (because your work should speak for itself, right :)). Then if we do basic multiplication 10 x 8 x 0 x 0 result would be 0!

If you are missing one of the traits for a great developer (great either by your standards or by community standards) your value could be 0. Does not matter whether you’re a 10x if you do not know how to communicate with your peers, your PMs. Or if you do not know how to communicate your value to the community.

Sources

Here are my sources for this article and links you should visit to learn more:

• What I’ve Learned in 45 Years in the Software Industry
• Multiplicative System Mental Model
• Building Trust Inside Your Team
• Curse of Knowledge

Like the whole internet and their grandma, I started writing a “2020: Year in review” article.

For those living under a rock, or who do not have a grandma, a “Year in review” article is an overview of your business, professional, personal, and family accomplishments in the last year. “Enlightened” ones tend to sprinkle it with few failures just to appear modest and down to earth :-)

After finishing a draft of all major sections and subsections my list of accomplishments was turning into a list of failures. Everywhere I just saw things I failed to do. Projects I failed to finish. Or even start. I know that when reading this article, a good friend of mine with whom I usually share my aspirations and ideas (you know who you are) would list my accomplishments from the top of his head.

Does that mean that I am a negative person? Unsuccessful person? Or maybe an objective one? :-D Or just a person without a focus, without grit, or clearly defined goals? Do I need to have goals defined when the year starts for me to be able to critically review them? To be able to objectively see which ones I’ve accomplished and which ones I failed? And to use failed ones as a plan for the next year’s goals? Can you be successful without defined goals?

Therefore I’ve decided to skip writing the “Year in review” article and instead write a list of goals in order to check against them objectively at the end of this year :-)

I had a good year. Especially considering the global pandemic with coronavirus. I and my loved ones were and are healthy. Financially and business-wise the year was solid. I’ve read a lot of books (52 to be exact, one for each week of the year) and learned a lot from them. Had a lot of time to pursue my hobbies and spend time outdoors. Hang out with dear people. Those that are across the “pond” only virtually but hey :-)

Woohoo, we’re already at lucky number 13! Did you know that number 13 is considered lucky to the Chinese?

Right, better get right into scrolling (and clicking hopefully)! Featuring @adamwathan, @marcelpociot, @calebporzio and many others.

Expose & Laravel Playground

Marcel Pociot was productive in the last couple of months and created Expose, free open-source tunneling service (ngrok alternative) written in pure PHP. It allows you to share your local websites with others via the internet.

He also created Laravel Playground — a free-to-use service that allows you to try out Laravel code (and all its features) directly in your browser.

I greatly admire people who can create and deliver products in such rapid succession. I’d be happy with myself if I was able to create and release one of my side projects. This is why this year I’m trying to work on smaller projects and tools and get my self in “release” state of mind.

Tailwind CSS: From Side-Project Byproduct to Multi-Million Dollar Business

Learn how Adam Wathan created Tailwind CSS and turned a helper library from his graveyard side projects into a multi-million dollar business. Succinct but inspiring as you never know where your possibility to make a “dent in the universe” lays :-)

And while we’re talking about Tailwind CSS — they recently released a plugin (called Tailwind Typography) that provides typographic styling for vanilla HTML you don’t control (like from a markdown or a CMS). A lot of users were complaining that Tailwind CSS was hard to use for CMS content (to me it was the only downside to it) and now they’ve addressed it, and they’ve fixed it pretty elegantly if I may say so.

11+ JavaScript Features You’ve Probably Never Used

Although I’m not a JavaScript developer, the title seems like a clickbait but my curiosity got better of me 🤨 There really are a few features that I’ve never heard or used before which seems useful and will definitely come in handy. Did you hear or used all of them?

Simple reusable React error boundary component

As the title says it is a simple React error boundary component that can be used to handle all errors thrown during React’s lifecycles. Plus it has a pretty nifty helper function for handling async errors. What are the error boundaries I hear you ask? Well, take a look at this Kent C. Dodds article for in detail explanation.

You’re already halfway through. Did you click on any of the links or are you just skimming through? :-) I’ll know if you did!

In the last two years, I read a library of copywriting and content marketing books. Here are my 15 takeaways to write better and faster.

Cool article with a lot of amazing tips for writing. I already included some of the tips in this volume. Can you guess which I’ve used? :-) Hemingway App (suggested here) is amazing as well — it calculates your text readability and suggests how to make it more so.

It even suggests replacing some more complicated words with their easier to understand replacements. This is strange because in my writing I wanted to expand my vocabulary and used a wider range of words to appear more knowledgeable — when in doing so I might have turned off some non-native speakers (one of the tips from the article ;-)).

Will Basecamp’s HEY Change Email Marketing Forever?

Overview of how email marketing might change due to Basecamp’s HEY email service provider and their screening and non-tracking features. This article provides advice and tips on how to approach these new trends and how to adjust your marketing emails.

I Just Hit $100k/yr On GitHub Sponsors! 🎉❤️ (How I Did It)

Story of how Caleb Porzio (whose products I’ve mentioned several times in the last few of the Interesting Reads volumes) got to over $100K on GitHub Sponsors. Besides navigating through the story of how that came to be, he also gives us “nuggets” he picked along the way and some of them might be helpful for just about anybody.

Caleb is extremely productive lately (Laravel Livewire, AlpineJs, and Sushi to name a few of my favorites) and his success story is an inspiration for how to be (financially) successful when creating open-source software without resorting to creating a SaaS product.

The Bullet Journal System

Excellent system for rapid logging that I’ve started using lately. It relies on just a few concepts but it is pretty powerful.

It uses bullets paired with different visual symbols (●, ○, and -) to categorize your data entries into tasks, events, or notes.

You’ve only added two lines — why did that take two days!

A list of great explanations why the number of lines of code does not tell anything about effort, value, or quality of work that was done. I’ve used almost all of the reasons listed here at one time in my career.

What kind of person (or a robot) are you to finish an article and not give an appreciation by clapping? What kind of message are you trying to send me? :-)

Hey! Another month has almost passed and that means that it is time for me to get motivated, write an intro, and carefully select interesting links from collected ones with a short text written for each of them.

We again have a selection of PHP (mostly Laravel but there are Symfony and WordPress reads as well) and JavaScript (React). Though there is a lot of assorted tech reads as well (and some CSS ones).

I hope you’ll enjoy the selection.

Why we at $FAMOUS_COMPANY Switched to $HYPED_TECHNOLOGY

https://saagarjha.com/blog/2020/05/10/why-we-at-famous-company-switched-to-hyped-technology/

Did you recently switched technology stack at your company and want to tell the world? Well, look no further saagarjha has already written the text for you. You just replace the name of the company and the new (and old) technology and you are good to go 😜

The IKEA effect

https://stitcher.io/blog/the-ikea-effect

Wikipedia defines the IKEA effect as “a cognitive bias in which consumers place a disproportionately high value on products they partially created”. Read how this applies to development and how to get rid of it. And while we’re at the subject of IKEA how cool are these homemade forts instructions released by IKEA?

Tools for better thinking

https://untools.co/

Collection of thinking tools and frameworks to help you solve problems, make decisions, and understand systems. Make sure to visit this website once in a while as they are adding new stuff regularly.

Ask HN: Am I the longest-serving programmer — 57 years and counting?

https://news.ycombinator.com/item?id=23366546

I’ve been having doubts about the longevity of a programmer’s career. Not sure if I’m hitting a mid-life crisis or just a regular existential one 🥳 It is nice and reassuring to see that I have over 30 years to go still and to see that “old developers” exist. Now, off to find if young pigeons exist as this is puzzling me as much as old developers 😃

Practical privacy tips for your business

https://blog.simpleanalytics.com/practical-privacy-tips-for-your-business

Overview of privacy issues (and solutions of course) that you may run into while building your products.

A (Mostly) Complete Guide to React Rendering Behavior

https://blog.isquaredsoftware.com/2020/05/blogged-answers-a-mostly-complete-guide-to-react-rendering-behavior/

Details on how React rendering behaves, and how the use of Context and React-Redux affect rendering. If you’re at all interested in deep diving into React abyss this is a must-read.

Recoil — Another React State Management Library?

https://medium.com/swlh/recoil-another-react-state-management-library-97fc979a8d2b

You think you know JavaScript? Guess again :) Read (and answer) this amazing set of questions to check your knowledge and fill its gaps. Great as a pre-interview repetition.

Eloquent Performance Patterns

https://eloquent-course.reinink.ca/

Awesome course for learning how to write performant Eloquent (and DB) queries to speed up your application and push more work to the database layer. This is definitely a purchase that has returns its value very soon. If you don’t believe me watch the two free preview lessons.

Tweet(storm) of the month

Awesome collection of tips for writing clean code in your Laravel products. Even commended by the Laravel man himself — Taylor Otwell.

Protect your Symfony application against the OWASP Top 10 security risks

https://nicwortel.nl/blog/2020/06/07/protect-symfony-application-against-owasp-top-10-security-risks

Excellent overview of the top 10 OWASP security risks with an explanation of how the Symfony framework is handling them as well as what you need to do to protect your app. I’d like to see an overview like this for Laravel though a lot of suggestions can be easily reused as-is.

Modern CSS Solutions for Old CSS Problems

https://moderncss.dev/

A cheatsheet with a list of evergreen CSS problems and modern solutions for them (with detailed explanations of given solutions) by Stephanie Eckles. Some of the solved problems included are equal heights column and fixed footer.

Tailblocks

https://mertjf.github.io/tailblocks/

Free collection of blocks (or templates) for the Tailwind CSS framework.

Kadence WooCommerce Email Designer

https://en-gb.wordpress.org/plugins/kadence-woocommerce-email-designer/

This is an essential WordPress plugin for any WooCommerce shop. With it, you can easily edit (both content and visually) all outgoing emails without needing to override templates or using hooks and filters. And best of all — it is free!

At the start of each month I’m stressing that I won’t find enough interesting links to share, but as month progresses and links keeps coming in, I’m stressing which one to leave out 🤔 If you’ve found anything that you’ve liked don’t forget to 👏

This month there may be more React links than usual due to me building a new web app using React hooks and learning the intricacies of hooks to stop DDoSing my app 😜

As there are 12+ interesting articles and you don’t have the time to read all of them, do not skip over the last one — “68 Bits of Unsolicited Advice”. There are also few short but appetizing reads.

Continuous Deployments for WordPress Using GitHub Actions

Continuous Deployments for WordPress Using GitHub Actions | CSS-Tricks

I was planning to test out GitHub’s actions and deployment was the one that made the most sense to me. This awesome article from CSS Tricks teaches us how to deploy and build your WordPress theme but it definitely can be used for anything else as well. It builds your package with Composer and NPM and uses rsync to copy files over to your production server.

If you are interested in DB migrations and deploying Laravel apps check https://atymic.dev/blog/github-actions-laravel-ci-cd/, https://samuelstancl.me/blog/push-deploy-a-laravel-app-for-free-with-github-actions/ or https://laravel-news.com/push-deploy-with-github-actions as they have good ideas and tips.

How to Create Custom WordPress Editor Blocks in 2020

How to Create Custom WordPress Editor Blocks in 2020

Overview of how to build a WP Gutenberg block by Peter Tasker. It leverages the latest tips, tricks, and tools such as create-guten-block. You don’t have to be a React expert to follow along and to build your own block.

React Hooks — Understanding Component Re-renders

React Hooks - Understanding Component Re-renders

Overview of most used React hooks with a detailed explanation when each of them is being used during component rendering lifecycle. Do read it if you are starting using React hooks and before you start DDoSing your own API endpoints. And while we’re discussing React Hooks, Kent C Dodds has written an excellent article on useMemo and useCallback hooks.

Logpoints: the best Chrome DevTools feature you aren’t using yet

Dan Abramov on Twitter

Logpoints: the best Chrome DevTools feature you aren't using yet. https://t.co/m2h7rMknUx

Awesome little helper in Chrome DevTools that can be quite handy and can save you the time to manually write console.log. As I don’t write a lot of JavaScript, console.log is my go-to debugging tool. I know you still use it too 😉

Sharingbuttons.io

sharingbuttons.io | Super fast and easy Social Media Sharing Buttons. No JavaScript. No tracking.

“Super fast and easy Social Media Sharing Buttons. No JavaScript. No tracking.” They most certainly do deliver as promised.

Favorite JavaScript utilities in a single line of code! No more!

Favorite JavaScript utilities in single line of code - 1 LOC

180 favorite JavaScript Utilities in a single line of code! This one is definitely worth bookmarking.

TLDR: Writing a Slack bot to Summarize Articles

TLDR: Writing a Slack bot to Summarize Articles

Learn how to integrate a state-of-the-art machine learning model into a Slack bot to generate a summary of articles shared by their URL commonly known as TLDR; (too long, didn’t read). It uses cortex.dev, serverless framework deployed on AWS Lambda and AWS SQS.

You don’t have to be Twitter-famous to grow your blog

Blogging for Devs: Free Email Course & Newsletter

Newsletter email course with great tips on blogging for newbs like me. JK, I believe everybody will find something useful there. Each day/email you get homework to work on :) If you’re interested in writing articles for money check out this great overview: https://dev.to/hyvortalk/10-companies-that-you-can-write-for-and-get-paid-as-a-developer-100-per-article-4dd7

Use Twitter to find developer friends near you

Use Twitter to find developer friends near you

A quick little tip on how to search through Twitter using geocoding.

We now use 100% renewable energy at the office, and at home!

We now use 100% renewable energy at the office, and at home!

By reading this amazing and inspiring article from one of the most coveted WordPress web agencies I’ve learned that B Corps exists and that the movement is marching ahead (https://bcorporation.net/about-b-corps). Faith in humanity and capitalism restored 😀

Doordash and Pizza Arbitrage

Doordash and Pizza Arbitrage

Fascinating article about food delivery business (Doordash and Uber Eats), which starts to look a lot like a negative-sum game (where at the end everybody is at loss). At best 😀

68 Bits of Unsolicited Advice

68 Bits of Unsolicited Advice

Awesome pieces of advice by Kevin Kelly (an author and former executive editor of Wired). The one that resonates with me the most is: “Acquiring things will rarely bring you deep satisfaction. But acquiring experiences will.” You need to bookmark this and read it once a week until you memorize them all.

So far sticking to daily scheduled 5 minutes of preparing content for Interesting Reads is working for me. Some days I’m spending less than 5 mins and just saving the links I find worthy, and on some, I spend more time and write a description for those links. I hope this becomes a habit soon so I can remove daily reminders.