DEV Community: Juan F Gonzalez

7 is the perfect number

Juan F Gonzalez — Fri, 06 Jun 2025 11:24:38 +0000

Can you remember when you first started here on DEV?

I can even though it's been quite long.

I remember the first post I did, circa August 2018, was after I finished a short coding Bootcamp that I got into thanks to a friend.

It's the first time I made a post of technical nature online in English (my second language).

I still cringe a little reading it... But it was a stepping stone into technical writing (which I'd later find out it's quite difficult).

I only started wanting to write for real in January of 2020. Made 2 posts that month, couldn't keep up with a regular posting schedule and then you know what happened that year...

With the extra time from being locked down at my home, I resumed the writing at the end of June and then kept going on posting (mostly) weekly for the rest of that year (and then the year afterwards).

It's been quite a wild ride with all its ups and downs.

And maybe it's time to come back here to post my learnings and experiences about my new undertaking in the World's Largest Hackathon of Bolt(dot)new.

Python Challenge Recap

Juan F Gonzalez — Sun, 20 Aug 2023 21:13:59 +0000

Hello again, friend!

I hope you had a great week in this mid-month of August.

This time I come to present you my results of the learning challenge I started this past week.

Let's get to it.

Intro

In case you are not aware, I threw around the idea of doing a challenge to show how long can it take to go from 0 to competent in a new language.

In this case, I went with Python because I was at a total zero knowledge when it comes to it.

And the whole goal was to learn enough of it to work on my first AI project and understand how LLM's work.

But one thing is what you plan to do and another one is what actually happens.

So, this is me telling you the "expectation vs reality" side of things.

What made the challenge harder

A couple of things here made this experiment a real challenge.

Like:

Prior to this, I haven't touched a line of code in 2 years.
I only have experience in frontend development, nothing backend related.
I didn't do much prep work beforehand and I didn't know what I was getting myself into. (The only thing was asking an AI what would be the 80/20 of Python)
I never picked a real date to start with it and instead was kinda forced to do it by the circumstances.
I started it in a week where other projects, tasks, and due dates converged into. (This has been a pretty busy week...)

It reminds me of that saying, "when it rains, it pours".

But I had to keep up with all of that regardless.

What made the challenge easier

This is the other side of the coin.

These elements made the experiment less challenging.

Like:

Python is a very beginner friendly language. And many people say it's great for complete beginners to learn.
There's a lot of resources for learning and there are several "crash courses" on YouTube for it.
Python is surprisingly similar to JavaScript. I found myself in many situations being like "hey, this is like X in JS!"
The challenge was scoped. I was not trying to "become a master in Python". It was more directed to get productive and start building stuff with it.

And all of these balanced things out and helped me get a head start compared to other approaches.

What ended up happening

The expectation was to put around 2 hours every day to start learning and practicing. Also, to do all the prep needed like having Python installed and a dev environment properly set up.

In reality... life happened.

There was a big problem with my ISP on Monday afternoon. Where I live and other close towns lost the Internet, TV, and phone service.

For more than 6 hours...

I was offline after 4:40 PM until I went to bed at 10:30 PM.

On Tuesday, I had several things to get caught up with and trying to finish what I couldn't the previous day.

A couple of articles to post, projects to make progress on, and people to talk to both for work and personal stuff.

On Wednesday, I was on a couple of meetings/webinars/and such. Kept making progress on work and several tasks.

Later on, 2 technicians came over to check if the service was working and to change the router for a new one.

It was until 5:30 PM that I could get a start to anything Python related.

I went through 3 "crash courses" on YouTube to give me some context. At 1.75x speed (2x is too fast and couldn't understand anything).

I also downloaded and installed Python on my laptop.

On Thursday, there was more work, finishing stuff, live calls, and such.

On the afternoon I picked back up the learning duties. But I was confused because it seemed like Python wasn't correctly installed. 🤔

And it turns out...

There's a version that can be installed from the Windows Store and there's the normal installer from the official Python website.

Path conflicts ensued...

...

Uninstalling and reinstalling with custom options made it work. (Time that I spent not learning the language.)

On Friday, I was getting really anxious because it was very close to the weekend and my progress in this challenge was minimal.

But since I made good progress in all the others tasks I had for the week, I could spend more time on the challenge.

I continued reviewing parts of videos, doing exercises from Google's Python course, and learning how to use Colab Notebooks for more "real world" practice.

Lessons learned

I'm by no means an "expert" at this point. But looking at production-level Python code no longer looks like I'm trying to read German (which I know nothing about it).

I'm yet to learn more about those "list comprehensions" that look like a really nifty feature of the language. Also, tuples and sets are structures I have to practice more using.

But now I know why the language is so popular. It's so versatile and it helps you do several things beyond "plain ol' software dev".

I now know the difference between AI, machine learning, and data science. They overlap a lot and it's easy to confuse them.

I have zero interest in linear regression, data visualization, statistics, and the research side. I rather be on the intersection between AI, algorithms, and user-facing products.

I also didn't use AI to help me with any of this, it felt like cheating. I only used the approach I would've 1 or 2 years ago.

(But imagine how farther could you go and how much you could accomplish if you used AI as part of the process.)

And now, lesson for you. Learning with an end in mind while ignoring the rest is the way to go.

But this kind of learning is more about mindset than aptitude or skill development at all.

You'll have to get used with being uncomfortable, looking like a fool, and not knowing what you're doing at first.

Before you can become competent and proficient faster than any of your peers.

That's one thing you should write down and post it somewhere nearby.

Conclusion

There you have it!

Hope you've learned a thing or two that you can apply for future projects or experiments.

Thanks for reading.

I'll keep bringing you more ways to improve and supercharge your learning.

Peace out!

Photo by Chris Ried on Unsplash

Diving into the serpentine end

Juan F Gonzalez — Mon, 14 Aug 2023 21:01:07 +0000

Hello friend.

If you've read my previous post, then you know what I'll be talking about.

(And if you haven't, now is a great time to do so...)

I didn't know when to start that project because I felt like I needed to do more prepping or finish other stuff first.

But this week looks like it's going to be the week for it.

Particularly because I got accepted to an online course which is live. And I need to have some background knowledge about Python (for which I have absolutely none).

So, from this Monday on, you'll see my attempt at going from absolute zero to knowing enough to work on AI projects.

And I don't mean this kind of absolute zero. 🥶

The challenge

That's going to be from now, Monday 14 all the way to Saturday 19 of August.

It'll be a learn and build kind of thing.

By Sunday I should have something built that I can show. Even if it's something small and not too ambitious.

Also, on that day, I'll be making another post like this with results and lessons learned from the challenge.

That's pretty much it.

I have a list of concepts & topics that I should learn first and a well laid out plan. All it needs now is some execution on my part.

We'll see how it goes.

Thanks for reading so far.

I'll talk to you again on Sunday.

Bye.

Photo by David Clode on Unsplash

How long would it take you to learn something new

Juan F Gonzalez — Mon, 31 Jul 2023 22:28:03 +0000

Hello there, my friend.

It's the end of July. The end of summer vacations for many people. And the start of the winds of August (well that used to be the case).

Since many people start moving from summer break into the 2nd working half of the year and others start going back to their studies

I think it's a good time to

The origins

Here's an interesting idea I had.

I've talked at length before about many concepts & topics related to learning.

From steps you can take to improve that process.
Getting better not only in the technical aspect but also the personal one.
Powering up your learning with better focus.
And making more progress with a different kind of practice.

But I realized that I've never showed you how that plays out in the real world.

Like how that would work for a new project/venture/endeavor.

And so, I think that doing an experiment around it would be valuable for you to see how it works and also give you some ideas to try.

Which brings me to this post's title...

Here's a question for you...

If you were to take on a new project or anything similar, how long would it take you to go from zero knowledge to getting good results in that area?

Huh?

Over the years, I've seen different timeframes.

Ranging from a few weeks, 3 months, half a year, 8 months, a whole year, and so on.

The important part here is not speed. It doesn't mean that someone is better than other just because is faster.

It is not a general competition of who's better than who. After all, we're all in different stages of our journey and our wants and needs are different.

The main thing here is improving over your past self. Don't try to be better than some random person out there.

Try and be better than you from a year ago.

This means, knowing what you know now, can you do something similar again and do it much better than before?

It's not only about small gains either... I'm talking a real marked improvement.

Let's say for instance, you were able to write and schedule 20 great social media posts in an hour. Can you do 40 equally great ones in 40 minutes or less?

That might seem too much of a random example, so let me give you a real one.

Back when I started writing online, I would take me 1 hour a day for an almost entire week to finish a blog post that's about 5 mins long.

With more practice I could knock out a full one from start to finish in 1 hour per day for 3 days and then have it ready to post on the next day.

Now, I can go from a mere idea to fully polished and ready to post in 2 hours. (True story, I did it last week.)

That's the whole point.

Not only doing more of something. Instead, do more, much better, and in less time overall.

But before you get to quality and volume, you first need to know what you're doing.
Or in other words, need to be able to walk first before you can run.

That's the general idea behind what I want to present to you.

The project

My idea for showing instead of only talking, is to show you how this different kind of learning (something I call "Supercharged Learning") works out there in practice.

But...

It won't be "just another random project". This will be more like a challenge.

Why a challenge, you may ask?

Well, for starters, I've already done several of these experiments over the past years. And going over the same process would be pretty dull (for me at least).

Doing a sort of "show and tell" and adding constraints would make it more interesting. With a time limit to make it actually challenging.

And for that, I thought about this time doing a Python challenge.

Here's how that would look like:

Going from zero knowledge whatsoever about Python to getting good enough to make my first useful machine learning project. In one week. Part time. Alongside my other responsibilities.

There will be a brief period of preparation, to gather resources and set out the stage, and then the week of the challenge. With a showcase of the results and then a brief review post with the good and the bad that happened.

That's it in a nutshell.

Is it clear enough?

Do you have any additions or suggestions for it?

Would you like to see something else or something different I didn't mention?

Let me know your thoughts.

That's it for now. I don't want to make this any longer than it needs to.

As always, thanks a lot for reading so far.

Keep on being awesome and see you again next time.

Bye.

Happy DEV Anniversary!

Juan F Gonzalez — Fri, 02 Jun 2023 21:57:00 +0000

Guess what happened yesterday?

I received in my email one of those cool DEV messages giving me good news.

I opened it up and this is what I found.

...

I can't believe it's been 5 years. Time really flies!

I first joined here before I even got my first developer job.

I was just searching resources to learn UI and frontend development.

And on October of that year, I accepted an offer to start working as a slightly more skilled junior developer.

Since then, everything changed for me.

I was a lurker here for the first years.

In January of 2020 I decided to start writing to share knowledge and help more people not only on as a volunteer on the company I was working with back then.

If it weren't for DEV, I would have spent more time fiddling around building my own blog and dealing with all the technical stuff instead of spending the time actually writing.

It has been a wild ride everything that has happened over the last years.

And I will always be grateful to this wonderful community for giving me the start and helping me discover my love for writing online.

Thank you all!

Don't get lost in the woods. Here, have a map

Juan F Gonzalez — Wed, 01 Feb 2023 17:51:30 +0000

Welcome back and happy new year!

2023 is upon us. There are many things that can happen, many that we can make happen, and many that will invariably happen regardless.

And since it's a new year, I can start writing about many topics in this and the following articles.

But...

I thought that instead of just getting started with those right out of the gate.

I'd be doing you a disservice if I don't make it easy for you to find those previous articles.

The ones that have had the greatest acceptance among folks and have helped some of them in their own learning journeys.

So, if you want to get the kind of "tl;dr" of this blog, keep on reading. You'll find a map to navigate everything that's worthwhile here.

Web & personal dev in a nutshell

Now, how this is going to work. I'll be grouping them in categories or "themes" and write a short description of them. Why they are important and why you should read them.

There's also going to be a "miscellaneous" section. For those that can't quite fit other categories but they're still relevant or out of the ordinary in a way.

So, let's get on with them!

Personal Development

First things first, we start with the most important.

This section is focused on you as a person on how you can improve and be better.

Because there's no point in having super-duper, ultra l33t haxxor skills, if you are a terrible person to deal with it and no one can stand you.

And so, we start with the essentials first. Which, conveniently, I have an article on that

Rediscovering the essentials.

In this one, I talk about the 3 main concepts or "mental models" that have helped me many times in the past.

These 3 are like the pillars from where everything else can built on top. In case you go to a transition in life or there's an abrupt change (like you know, a sudden pandemic...)

After that, we move on to one of the most foundational building blocks, habits.

Bad habits and how to break them.

This is a short story of how I picked up a big number of bad habits while in college and my battle to overcome them.

It also has practical actions you can take to break your bad habits and build more beneficial ones. Some of that advice is taken from one of my all-time favorite books.

And once you have good habits in place, we move forward to put them in a working order. Starting with some proper routines.

Routines, our different operating systems.

Here you'll find what routines are, why they are important, a small peek into the operating system of the brain, and how to actually implement all that into your own life.

With all those things in place, you're in a much better position than the majority of people out there. (No, really, for sure.)

What we can keep doing is keep piling up small improvements over and over to get better results. But as doing work is important, so is taking the time to properly rest & recover.

Which leads me to...

Making good progress minus the burnout.

This one comes from that time where I took the challenge to write a new article each day for 5 days straight.

In it, you'll find that approach I mention to make incremental progress without getting to that dreadful place others call "burnout".

Lastly, I can't forget about this last one. I was a more "experimental" one and the few of those who got some peer feedback before getting published.

To learn something, get your focus on first.

In this one, you'll find one, if not the most important, aspect of learning things quickly and efficiently.

And I'm not going to spoil the article, so I'll leave it at that. 😆

Web Developmemt

Now, we move on to the more commonly known form of development.

There are several articles in this section. But only a handful were the most popular and valuable for others.

So, here's that top selection for you.

Creating a new project, no design skills needed.

This one is for all those folks out there that are doing front-end web development. But they don't have any notions of what constitutes "good design". Fortunately, there are tools out there that helps us with it.

Hone your dev chops with Svelte.

Speaking of front-end...

The newest "kid on the block" of JavaScript, brings us all the good stuff of classic web development.

And as well it gives us the opportunity to use that knowledge in real-world, production-ready framework. (This is even more relevant now that SvelteKit exists.)

Making a quote switcher with JavaScript.

And yes, speaking of classic web dev and JavaScript...

Here's an example on how to build something pretty cool and functional without using any fancy frameworks or libraries that are popular out there.

Level up your git workflow.

What is web development without a proper workflow for managing changes and updates to our projects?

That's where Git comes into play. And although I've written about it in quite a few articles, this one is the one that stood out the most.

Misc

In this section is where there are other articles who didn't make the cut in the previous two. But they're still useful and at least entertaining (maybe?)

Like the first time I wrote an article for someone other than myself and was the beginning of me realizing that writing can actually be profitable.

(And not only used for knowledge sharing or personal reflection.)

How to get out of "tutorial hell".

In this one you'll find about that common scenario that most of us have found ourselves in some time here and there. And how to use some practical techniques to make sure that you can expand your knowledge out of the bubble of an online tutorial.

Or the first time that I wrote an article recapping the events of the year. In a similar way to how development teams do after they finish a working sprint.

2020 Retrospective.

This one is just as the name implies. What happened in that year in a retrospective format. And a look to the future and possible events happening.

Or the first time I got an article featured on Hashnode.

Learning something new by writing.

This is mainly a recap and lessons learned from my aforementioned 5-day writing challenge.
And guess what? I wrote about 5 different lessons there. Kinda one per each day. Although I didn't plan to do it like that, it just happened that way. 😆

And lastly, the article where I combined some of what I've talked in previous posted ones with some meta-learning and memory techniques.

Learn web dev easier with this trick.

This one is pretty much what I said above about it. Even though it's geared towards learning web development, the "trick" works for other types of subjects. You just have to understand how it works so it can be applied to other areas.

Conclusion

And that's about it for this article.

I think it went a little longer than expected. Then again, I wouldn't be surprised seeing that it has happened many times in the past with others as well. 😅

But like I said at the beginning, this one was meant to give you a whole "overview" of what you can find in this blog.

And is also to help surface some gems that are now buried in the sands of time (of previous years).

Nothing left for me to say at this point. Other than thank you very much for the time you've spent reading this or any of the other articles posted in here.

I really do hope that you've found some value in them and they have helped you in some way.

Thank you for being awesome and I hope to catch you again next month!

Photo by Tabea Schimpf on Unsplash

Looking back on this year

Juan F Gonzalez — Sat, 31 Dec 2022 17:32:12 +0000

Hello, again my friend.

We meet again one last time before the year ends.

What a crazy year it's been right?

A lot can happen in one year. Especially when you choose to make your path, pursue your interests, turn your curiosity into passion, and then go out there to seek it no matter where it takes you.

Doing a recount of what happened this year would make this post pretty long, more than 10 mins to read. So in the interest of not rambling and instead giving some practical takeaways...

I'm going to do a brief overview of the main hits of this year along with some lessons I learned that I hope and help you in the coming one.

So, let's get on with it!

Beginning of the year

In January, I don't remember why but I was really into health, fitness, improving my immune system and such. I was using most of my free time to read and learn about those topics.

In the last week of that month is that I chose to quit my previous job before I got laid off (or worse).

Since I started doing technical writing in mid-2020, I've been more interested in writing words on the internet instead of code that very few people will see, or have a positive impact on.

And so, I went more on that writing route instead of the coding route.

I posted one article in January and then had another one scheduled for February.

But due to unforeseen events that happened, I missed the mark.

I went live at the beginning of March instead...

Why am I telling you all this?

Because in that post I described what I thought my journey was headed towards.

You can read that one here. If you're curious or missed it at that moment.

Writing of different sorts

In this part, I had to check emails from the first few months. Just so I can remember better what was happening back then 😅

But yeah, throughout the year I reached out to some folks (and also got contacted by others) to do some guest posting and to create content for their platforms and communities.

First, it was with the Aviyel community. I was able to contribute a post for them on different options of styling for React.

The folks from Codespresso reached out and said if I wanted to repurpose some of my posts from DEV into "code shots". Small bite-sized pieces of code.

I also got in contact with the Codiga people for an article about VSCode snippets and dev productivity. (That one didn't happen in the end).

Around October or so, as luck would have it, I got in contact with the guy running the WonderShuttle studio.

This time it was for Technical Ghostwriting. For my first assignment, I was to write a piece as if I was talking on behalf of the CEO of GitLab.

The topic was about the advantages of open-source for a business model and how it could work for other big-scale tech companies.

The end of that one was... quite peculiar I could say. It's a long story. In the end, the folks there replied, gave me feedback, and also paid me for the work.

Can you imagine that?

It was my first successful gig as a Technical Ghostwriter!!

Plus a chance for continued work on other projects. (Which I'm hopeful can happen this coming year).

And now...

For the last kind of writing that I discovered this year...

That one is called... Copywriting.

Let's just say that was the kind of writing that I've put the most hours into since the start of March all to September.

Boy, I never even anticipated how much my life would change by developing these writing skills.

And what's cool is that it plays into my existing skills.

Mainly my big o̶b̶s̶e̶s̶s̶i̶o̶n̶ interest in social psychology. Along with behavioral cues, personal development, and some tricks I picked up being a mentor in coding boot camps.

I think here is where the first main lesson comes into play.

Don't be afraid to explore other areas while you keep improving your skills. Lifelong learning is a journey that can take you places you wouldn't expect.

Leverageable skills and other goodies

I always thought that programming skills would be my swiss army knife for all things delivering value and making a living out of it.

After all, if you think about it.

You can develop an app or site, deploy it, and have it running constantly with some maintenance. So you could leverage the time spent developing into recurring revenue each month. (Or so I thought).

And after being in the tech industry for a little over 3 years...

I realized how wrong I was.

Most of the time, coding is the easy part.

Communicating with stakeholders, prioritizing features, dealing with scope creep, working on different interdisciplinary teams, and so on. That's a whole different story.

Coding in general changes and evolves constantly. You have to catch up constantly and there are no certain things or repeatable patterns that you can take advantage of.

In marketing, that is different.

Why?

Well, for starters human psychology has slightly changed for most of the time we've been living on this planet.

And so, whatever it is that we build. We need to attract people's attention to it.

The worse thing is spending a lot of time building something that no one cares about.

So I think I put too much time into that and neglected the content I post in here monthly.

Sorry...

More kinds of development

I wasn't completely out of the web development space. Although I dipped in and out of it a couple of times throughout the year.

I also kept advancing further my self-development initiatives.

Ones like...

Joining Brian Johnson's Heroic platform.
Taking part in some fitness challenges.
Developing some relationships with people IRL.
Doing some traveling with whom were my friends at the time.

Several of those shenanigans kept happening until August.

Quick side note: I used my writing skills to help a friend with a new job she got managing social media campaigns. It started well and I don't know who screwed up but it ended up being a mess. I didn't get paid for my time but I at least got some experience... writing on a language I'm not going to be using much 🤷‍♂️

After that, I started writing on the Tealfeed platform and started refining the topics and areas I would be focusing on most for the rest of the year.

I took my Twitter account and repurposed it for a new goal.

To help other fellow knowledge workers to learn faster, more effectively, acquire new skills and be more confident performing in the workplace. Whether that is on a job, as a freelance, as a biz owner, indie hacker, or whatever else.

And this is a good moment for another lesson learned.

The market is constantly changing. Some technologies come and go. New skill sets are now demanded. And for most people, having 1 job and 1 source of income is very risky.

In Conclusion

The last 3 months of the year were the ones with the most activity. I've done a bunch of different stuff. Explored many avenues. Found out that there's more hype than substance out there in every industry, not only the tech one.

Found several things that don't work (or at least not for my situation). Found a few that do work. And in general, realized that simplicity in everything is the key.

I went from having a full-time coding job to being a freelance writer and developer. To move more towards the indie hacker/solopreneurship road and now being set up with multiple income streams.

It's been quite the ride.

Onwards to 2023

For the new year, I want to double down on what has worked and little by little drop what hasn't.

I plan on taking all the content that I've written here, on Twitter and elsewhere. And turn that into a course of effective learning.

But not the traditional type of online course, noooo.

I've done quite the amount of research this year to know that the traditional route won't cut it anymore.

I also plan to create a newsletter where I can not only share some of the best stuff I've found and tried. But also to run learning experiments and share the progress on new ventures.

Hopefully inspiring much more people to take the leap themselves and dare to do the awesome things they're capable of.

And as for this personal blog. The "Web & Personal Dev" blog.

It will keep living on.

As I mentioned in the previous post, I will keep writing about tech topics. But more on the real practical side.

That is, using technology to enhance, improve, protect, and change our lives. So far, AI and Cybersecurity are 2 topics on the top of my mind.

And if you think about how I'm going to transition from Frontend development to those fields...

Well, guess what?

It's going to be a great opportunity and an experiment to put into practice those "effective learning" skills.

Stay tuned if you want to know how that goes.

Now congrats! You've arrived at the end of this post.

Like I've said in the past 2 retrospectives I've done here, thanks for reading.

Even if it's the first post you've read or you've been doing it the whole year.

Keep on learning, keep on improving, and keep on growing as a person not only as a knowledge worker. There's so much to do, places to see, people to meet, and lives to change.

Here's to the new year and bye-bye to the current one.

Until next time...

Make coding challenges surprisingly easy with these tips

Juan F Gonzalez — Fri, 30 Sep 2022 01:19:22 +0000

Hello friend!

Welcome to another post about... well you kinda already know what is from the title.

This time we're going to talk about how to tackle coding in general in a different way so that it doesn't look like that big and scary challenge.

Having said that, let's begin!

Intro

Programming sometimes can be a mind-bogglingly difficult task. Trying to figure out the right way to write code can be frustrating and can lead to us getting stressed out.

But don’t let that stop you; the more you learn about it, the better you’ll become.

So how do we get better at it? Well, there are many ways; from how we prepare, to the specific programming languages we use. But in here I want to share with you some effective ways to become a better programmer in much less time.

Jump-start from the beginning

There are many ways to jump start from the very beginning. One way is to define what's that you want to do first. Having an aim of what you want to do in the future is better than picking a language only because it's "popular".

Sure, there are multipurpose languages that you can learn, but some are better suited for specific tasks than others.

For example, JavaScript has always been popular because it's the language of the web. But other very popular ones are PHP and Java.

This are tried and tested languages that have proven to be functional and reliable and have their use in the backend.

Something else you can do is to start learning right from your browser. You don't need to have a full developer environment to get started learning a language.

Some languages have tutorials online that you can get started with without installing anything on your computer.

For instance, you can learn Ruby online and you can also learn Haskell online.

Once you've learned the basics of the languages, you can start building programs with them and see if it makes sense to you.

If for some reason you feel the language — whether is the syntax, the structures, or something else — is too abstract or obtuse for your mind to grasp, you can try a different one and see if vibes along better with you.

Write code early and often

One of the best ways to get better at programming is to write code. That doesn’t mean, however, that you need to sit at your computer and scribble out your next computer program from start to finish.

While this does indeed work, it takes a long time, and you don’t really learn anything. Instead, write code often. This can include taking a sample program from a tutorial and adapting it to your needs.

You could also write a program that automates repetitive tasks using python for example, or a write program that searches the internet for certain information and then log the results.

Next time you have a practice session you can take some of your programs and modify them. Add extra features or change the functionality of existing ones.

Reflection is key

When learning to code, it’s important to be mindful of everything you are doing. This includes every choice you make, every action you take, and every breath you take.

Well... maybe not, don't take it that far 😅

The reflection part is important when you start developing your skills. This is because as you start to become better at coding, you will naturally become more confident.

That, however, doesn’t mean that you have to become arrogant. Instead, you need to build on that confidence and become aware that the more you learn, the more you realize that there are much more things to learn.

This is something quite common not just in coding.

As you become better at it some things are going to become automatic and you won't pay them much attention. That's a common source of bugs later on.

I've been searching for hours what the error might be and haven-t find it...
Ahh... I see now, I forgot a semicolon...

There are some things that might seem dumb at first but usually that's where you have to look.

Be curious about new things

New advances in development are always coming about every month or so.

This includes what new frameworks pop out, what programming languages are now used, or what will be the tooling of the future. Zig language doing rounds out there am I right?

When it comes to learning coding, try to be curious about new things. This can include what people are saying about new tools, what new trends are in the coding industry, and what programming languages will be important in the future.

By being curious about new things, you can have an easier time going about the learning process and don't get stuck on just one topic.

That, in turn, will allow you to pivot to something else that you might find more enjoyable (or profitable).

Curiosity is not only a powerful motivator but also a good way to direct your learning.

Don't Stop Learning

It’s important to remember that no matter how confident you are in your programming skills, you are not done learning.

That doesn’t mean you will forever be a novice programmer, or that you will never be able to write a correct program from the start.

It simply means that you're on the continuous path of lifelong-learning and you will always have the chance to improve.

But this shouldn't discourage into thinking that is a waste of time to try to learn something that will never end.

Instead, see it as a way to become a more skilled professional and a much better person that your previous self.

By being a student for life and putting in the practice sessions, you can keep developing your coding skills, while also having fun in the process.

Conclusion

There are many ways to become better at coding, and we have outlined just a few in this post.

Pick a language you aren’t as familiar with, write code often, reflect on what you do, be curious about new things, and don’t stop learning.

These tips will allow you to become better at coding more efficiently and get more done at work as a result.

Keep in mind, however, that good programming takes time. It’s okay to take a break from coding and come back to it when you have more time.

It’s also okay to take a step back and think about what you are doing. This can help you become more aware of how and why you are coding, and how you can get better at it.

That's it for this post! Thanks for reading all the way here (if you made it all the way here that is...)

Hope these tips are useful so you can apply them to your own coding journey.

If you have any questions or comments, let me know and let's talk about it!

See you next time.

Photo by Danial Igdery on Unsplash

How Deliberate Practice makes you an epic developer

Juan F Gonzalez — Wed, 31 Aug 2022 23:27:24 +0000

Well hello there. Long time no see.

Yeah, I know. I've been the one who went missing for quite a while.

But I had to return regardless of the situation or whatever obstacles I found in the way.

And I'm back with recharged enthusiasm and more practical things to share.

With that being said, let's get on with this article!

Introduction

Software development is a highly competitive field. If you want to succeed in this field, you need to be able to code. But software development is also a field that is constantly in change.

If you want to grow as a competent software developer and make sure that can perform properly, you have to work on your skills. Not doing it only because "certain department said so" but doing it constantly to keep your skills sharp and ready to use.

Best way to do this? Two words: Deliberate Practice.

What is deliberate practice?

Deliberate practice is a method of learning that is specifically designed to improve your performance. It involves working on your skills with the intention of becoming better at them. Deliberate practice is different from normal practice in that it is specifically focused on improving your performance.

Deliberate practice is also different from learning new things. When you learn new things, you are trying to acquire new knowledge or understanding.

With deliberate practice, you are trying to improve your performance by developing new mental representations that let you do things you weren't able to do before.

It allows you to see on a general scale your strengths and weaknesses. With it, you can know what areas you're competent in and identify others where you need to improve. It also helps to keep your goals in mind and know if you're moving closer towards them.

Plus, it helps you to make sure you are practicing in a way that's most effective.

Deliberate practice is not easy and it takes much more effort than traditional practice. It will be uncomfortable and not always feel rewarding and fun.

The good part?

It will help you improve faster than usual. You'll get to a point where you'll be amazed at the things you can create. You can afterwards look at previous projects and be like "damn, did I do that myself?"

Why is deliberate practice important?

Aside from the already mentioned benefits above, deliberate practice has one characteristic that separates it from other kinds of practice...

Allowing you to do things that you previously thought were not possible.

You might think, isn't that what regular practice does in general?

Not exactly. The regular type of practice we were taught in school or college, was pretty much "repeat the thing over and over until you know how to do it in that specific context".

In contrast, deliberate practice allows you to have a better view of what you're good at (maybe because of previous knowledge or natural affinity) and what you truly suck at.

Talking about software development, most people I know of have only one of the things mentioned above (natural affinity). This makes learning the craft a rather difficult process compared to other areas of human skill.

But the important part here is...

It'll help you improve faster and deliver greater quality of work.

How to go about doing deliberate practice

Since this type of practice is structured and intentional in its way of doing things, there are certain aspects that are necessary to take into account when doing it.

This involves setting specific goals, breaking down the task into smaller components, getting feedback, and gradually increasing the difficulty of the task.

More specifically, these is what you need to keep in mind when doing deliberate practice:

Set specific goals. What do you want to achieve with your practice? Make sure that your goals are challenging but achievable.
Break down the task into smaller components. This will help you focus on one specific aspect at a time and make it less overwhelming.
Get feedback from a trusted source. This could be a mentor, coach, or even just a friend who is willing to give you honest feedback.
Gradually increase the difficulty of the task. This will help you push yourself and avoid getting stuck in a rut.

That is a more detailed roadmap of the steps you have to take to make sure you're having actual progress instead of rote repetition that "feels" like you're accomplishing something.

If you keep these steps in mind, you can make real progress in your development career and progress much faster while creating awesome things in the process.

Conclusion

Deliberate practice is a skill that is invaluable for all of us as software developers. It is the process of actively working on a skill to improve and refine it.

It works better when we are consistent with it and devote at least an hour a day for it. Even though it helps us progress faster than usual, it still takes some time for it to be effective. There's no "magic pill" or "overnight success's" here.

There you have it. How you can become an epically skilled developer by applying deliberate practice in your learning process.

If you came all the way down here, I appreciate you 🤗

Thanks a lot for reading. Hope it was clear and useful. If you any questions about this I'm always happy to help. Shoot them my way!

Take care and see you in the next one.

Photo by Brett Jordan on Unsplash

Make learning web dev easier with this trick

Juan F Gonzalez — Tue, 21 Jun 2022 13:35:37 +0000

Hello there friend.

In this post I want to tell you about a memory trick I've been using since my college days but haven't really put all the pieces together before.

I've been using in different situations to learn all kinds of stuff. From web dev, to psychology, neuroscience, social dynamics, body language, mindset, fitness, physical performance, health improvement and so on.

Lately, I came across a video that put words to those notions I have and helped me made the connections necessary so I can now explain that intuition to friends and others.

So let's get on with it shall we?

Intro

Now suppose you are on your web development journey and you want to further improve your skills in creating better looking layouts for websites.

You already know well your HTML and CSS chops and you want to take things up notch.

You can look into a CSS preprocessor like SASS or Stylus. Or you can check out a styling framework like Bootstrap or Bulma.

Or you might want to go more into the spec and strengthen your Flexbox or Grid muscles.

Regardless of what you decide to use, the process is going to be very similar.

You read the docs or watch a tutorial, see how it works, get acquainted with the basics and might even start making some things on your own to go from "passive learning" to a more "active" one.

But of course, you have a pretty limited base of knowledge to start making things with so you constantly go back to the docs or to that super-duper tutorial you learned from and re-watch what you have missed or forgot about.

And this happens even to the best of us when we want to recall something we don't use often or we did some time ago and never had to pick up again.

We may miss something or misplace the order of variables or even change the name of functions altogether.

"What was that function for separating arrays called? Slice? Splice? Split?.... Hmm..."

Or it happens when you're using Markdown syntax and can't remember how is it that a link can be embedded within the text.

"Was it brackets first and then parentheses or the other way around?"

"Hmm let's see… (this is a link)[https://twitter.com]"

"... Dammit! that didn't work… Oh well"

That can certainly be frustrating when you encounter some things that it doesn't matter how many times you've used them in the past. You can't remember how is it properly used…

(Yeah, I'm looking at you RegEx...😒)

Definitely some subjects are more involved than others, but it feels like some that are supposedly "easy" just come and go and don't really stick into the mind.

And then when you want to recall what you learned to apply it in a project or somewhere else, your brain just gives you a 404 "topic not found" error.

...

Don't you just wish you could download the subject into your brain and be able to start using it?

You know, kind of like in The Matrix.

While we can't do that just yet, there's something we can do to approximate that effect.

But before we do that, let's look at why we have difficulty remembering in the first place.

The inner workings of "working memory"

Working memory is a temporary storage that we have in the brain and it allows us to store and manipulate information that we are working with in the moment.

For instance, when your doing mental math you can "see" the numbers in your mind and use them to come up with the result of the calculation.

Or you also use it when someone tells you a phone number and you remember it until you write it down.

Think about it as a temporal storage that you use to hold information relevant to the problem(s) that you are dealing with.

Said it in another way, it's a "hot" data storage. Whereas your long-term memory is the "cold" data storage.

What's interesting about this is that working memory is a "multi-compartment" system. It can hold different types of data that we may need, not just numbers.

Source

It has a section dedicated with the "visual side" which is what allows to see things in the "mind's eye". Another section is dedicated to the "auditory side" which some people use to remember info by repeating it to themselves (like a phone number or an important history date).

And it has a "central executive" part which is the responsible for coordinating the processes of the other sections and communicating with long-term memory (the "cold storage" remember?)

Now, this storage is usually limited to about 7 +/-2 units or digits. This is one of the reasons that we can remember cellphone numbers but not something like a credit card number.

The way you can sidestep this limitation is by grouping together digits or pieces of information into single units.

Using this "chunking" process, you no longer remember a number like 300358249 digit by digit but instead remember it like: 300, 358, 249.

This way we've only used 3 units of memory instead of nine!

And we can take it a step further by associating groups of numbers with an image or object and then we just hold 3 images in memory which we use to retrieve the entire number in order.

This is one of the ways that memory masters use to remember seemingly "impossible" things. (Like, you know, the first 100 digits of Pi.)

What's awesome about this is that you are basically compressing information that you can save for future use and when it's time to use it, you take it back and extract the contents.

It's like using a zip folder.

Now, knowing how this "memory compression" thing works, let's see how you can take advantage of it to store important concepts in your memory while on your learning process.

The memory trick explained

The trick is essentially to create your own developer cheat-sheets.

Ta-da!

But, bear with me on this.

You might think "why would I need to make another JavaScript cheat-sheet when there are tons out there in the internet?"

There are a couple of reasons why that you might not be aware of right now, so allow me to tell you.

You gotta make that cheat-sheet in a sheet of paper about the A4 size. Everything that you can fit in there is the most relevant stuff that you need to know or have a hard time remembering.

We can go a step further with the "compressing information" process and use all sorts of strategies like mnemonics, small drawings, key facts, rhymes and such to take concepts and reduce them to a small portion and fit them into the sheet of paper.

By doing this, you're "actively" engaging with the material and getting your brain to process it. Doing it well enough to reduce the nonessential and stick with the important pieces.

Later, creatively turn those pieces into a mental representation that you can sketch or write and fit into the paper.

You can also use location as a way to remember the concepts better.
(e.g., put the mnemonics or images in the order you learned them so you know what goes after what and even create some form of storytelling between all of them.)

And by using a smart layout, or other creative techniques, you can make the sheet memorable enough to put it in your visual memory.

So the very process of creating the cheat-sheets themselves is what will help you commit the information to memory, organize your thoughts, and greatly enhance recall in the needed moment.

A great example

To show you a little more of what I mean, check out this very nice cheat-sheet about Git from the great folks at Egghead.

It has some of the techniques I've mentioned for representing concepts and helping remember the syntax of some of it's commands.

The thing with cheat-sheets is that what other person used probably won't make much sense to you and viceversa.

If a person prefers sketching things and you lean more towards writing things in a specific layout, then your cheat-sheet would help others who prefer actual text instead of images.

Conclusion

Using this memory trick you can take pretty much any subject and git commit it to memory ;)

It doesn't matter if the subject is something like syntax of Sass mixins,

or JS array methods…

or GraphQL fragments…

or React hooks...

or anything else.

You can get creative and use it to learn all kinds of subjects, even those who don't lend themselves too well to being restricted to a sheet of paper.

So there you have it! The memory trick to make your web development learning process much easier. Try it out and let me know how it works for you.

You can also adapt it to your learning needs and see what you can change and improve after using it for a while.

That's it for this post. Hope it's been useful and gave you a new tool to keep going on your learning journey. Making things a little bit better each time and keep improving on what is possible.

As always, thanks a lot for your time. Take care and see you in the next one.

What's up with the number 4?

Juan F Gonzalez — Wed, 08 Jun 2022 21:32:05 +0000

This week I was checking out my email to catch up with things from the previous week.

There was nothing out of the ordinary initially.

But then, I found something that snapped me out of my ordinary email-checking state.

You wanna know what it was?

Well, nothing more and nothing less than a new badge in dev.to.

But not any kind of badge mind you.

It was THIS badge.

Yo, that's a big, cool-looking number 4.

"Can you believe it's been 4 years already?!"

I couldn't believe it at first. But on further inspection, I found it's true.

It got me doing a trip down memory lane to the second half of 2018.

I remember that I had seen some posts from folks here going around. And after several of them, I ended up thinking "let's just sign up for this site right? why not?"

I didn't have very much activity on the site until August of that year when I wrote about experiences in a short coding boot-camp that I took.

The response I got was pretty positive. Initially, I was just reading/learning from posts and commenting on those, no writing on my part.

It wasn't until the beginning of 2020 that "writing" became part of my "new year resolutions".

I wrote only 2 posts before realizing "damn, this writing thing is actually hard".

Then, the pandemic struck and everything came crashing down.

In June I started writing again after a period of depression and nihilism. Writing on this platform and sharing knowledge was one of the ways I used to cope with the situation and keep moving on.

From there, I've gone to develop my writing skill…

Had writing streaks for many weeks…

Learnt a lot from tech and otherwise…

Met incredibly smart, cool, talented people…

And be part of one of the best communities for developers on the internet.

It's been quite a journey with ups and downs but definitely never a boring one.

I'm looking forward to what may come in the future and hopefully keep doing this challenging, but rewarding activity for more years to come.

So, cheers for this anniversary and another year to come.

And as always… Thanks for reading!

Back to basics: Data fetching in React

Juan F Gonzalez — Wed, 25 May 2022 19:52:12 +0000

Welcome back friend!

In this article we're going to take a look at one of the basics when working with React.

That is, getting data from an external source and using it in our application.

With that being said, let's get on with it!

Setting the stage

Suppose that our task is to retrieve data from an external API and display it on a page. We'll be doing that using only React and the inbuilt functionalities of JavaScript. No external libraries needed.

You might be asking why since there are utilities out there that can speed up the process for us.

The reason for that is twofold. First, most of the times we become a little too dependent on abstractions that don't let us see how things work in general. Second, for the purposes of this article we'll use just what vanilla JS provides us.

Also, revisiting the fundamentals is always a good thing to do when we want to deepen our knowledge and have a better grasp of what we think we know.

Now, lets move on to the details.

Getting the data

We are going to fetch data from an API and present it on a page. The first thing that we need is that API endpoint that we can call.

What could we use that we haven't used before?

Hmm...

How about we use the Rick and Morty API?

We'll fetch the data of the characters and that's what we're going to display on the page.

If you read the documentation you'll find that the endpoint we're looking for is in this form

If we make a GET request there, we'll get an object with some metadata and the data we're expecting of the characters.

Something like this…

So the results array is what we're mainly interested in. That's what we're going to save as our data to be displayed on the page.

Now, let's create a function from where we're going to be fetching that data. And we'll be using the Fetch API for that (remember no external libraries needed)

We'll now have something like this:

function getRickAndMortyData() {
  const apiUrl = `https://rickandmortyapi.com/api/character`;

  fetch(apiUrl)
    .then(res => res.json())
    .then(data => {
        console.log(data.results)
    })
    .catch(error => console.error("The error was:" + error))

}

That works as our base for getting the data from the API. Now, we'll want to take that data and display it on a page. That's were React comes in to help us out.

Displaying the data

First, we're going to create the markup for the page.

We'll have a header and a section where the data of the characters will be displayed.

Something like this for starters.

<header>
  <h1>Rick and Morty characters
</header>
<main>
  <ul>
    <li>Rick</li>
    <li>Morty</li>
    <!-- ...more characters -->
  </ul>
</main>

Now, we'll improve our previous function with some React powers. For instance, when the call to the API gets made, we'll save those results in state so we can use them where necessary.

If you've been using React for a while you will remember that we use to have Class components where we set the initial state and then made the API calls on the componentDidMount function.

But since the introduction of hooks, we no longer need to use those class components. The getRickAndMortyData function can now remain as a regular function.

The only changes we'll need to do are the introduction of the hooks for setting state and handling API calls. So we'll change it accordingly like so.

function getRickAndMortyData() {
  const [info, setInfo] = React.useState({ 
    characters: [] 
  });

  const apiUrl = `https://rickandmortyapi.com/api/character`;

  React.useEffect(() => {
    fetch(apiUrl)
      .then(res => res.json())
      .then(data => {
        setInfo({ characters: data.results })
      })
      .catch(error => console.error("The error was:" + error))
  }, []);

  return info;
}

Next, we'll take the current markup and improve it with the creation of components. One for the header and one for the characters.

First is the Header component that can be something like this.

function Header() {
  return (
    <header>
      <h1>Rick and Morty characters</h1>
    </header>
  )
}

And then is the Characters component that will be listing the characters data that we received from the API.

function Characters({ characters }) {
  return (
    <ul>
      {characters.map((character) => (
        <li key={character.id}>
          <img src={character.image}            
               alt="character picture" />
          <label>{character.name}</label>
        </li>
      ))}
    </ul>
  )
}

With that done, we only need to use them in the markup passing in the correct data that's going to be displayed.

So the App component will look like this.

function App() {
  const data = getRickAndMortyData();

  return (
    <>
      <Header />
      <main>
        <Characters characters={data.characters} />
      </main>
    </>  
  )
}

Putting it all together

With all those pieces in place, you'll see that the characters now appear as a list with just 20 of them at first.

If you look at the documentation, you'll see that the response from the API already comes paginated.

In the info object that contains the metadata, there's the info of how many pages there are and the links of the next and previous pages (if they exist)

Knowing this, it wouldn't be difficult to implement a "next page" button that will bring the next 20 characters in the list.

Although, that's something you can implement as an extra credit for this particular exercise. We'll not be extending this article further with the implementation of that functionality.

Wrapping up

The styling of this exercises is up to you to make it look however you like.

I personally made it very minimalist with these few lines of CSS.

body {
  font-family: Arial, sans-serif;
  text-align: center;
}

ul {
  list-style-type: none;
}

li {
  display: flex;
  flex-direction: column;
}

li img {
  height: 130px;
  width: 130px;
  align-self: center;
}

li label {
  margin-bottom: 1rem;
  font-size: 18px;
}

And here's a codepen with a working version of this app.

There you have it. A simple React app that gets some data from an external API and then displays it on a page. With no other libraries required. Just Vanilla JavaScript.

"Look ma, no libraries!"

That's it for this article. Thanks a lot for reading. Hope it was informative and clear enough for you.
If you have any questions or suggestions for this. Send them my way!

Take care and see you in the next one.