DEV Community: Max Shapira

Skills vs AI

Max Shapira — Wed, 23 Aug 2023 11:00:09 +0000

Being a skilled developer requires a careful balance in this fast-paced AI era. You should refine your skills naturally while still leveraging AI. It's not easy, as it takes practice to ask the right questions and create a fresh perspective (if you're stuck in old habits). Let me share a few ideas for striking the right balance.

Use AI for Understanding, Not Just Answers
Break Down Your Problem
Ask for Resources, Not Direct Solutions
Request Feedback
Use the Socratic Method
Self-Reflect Before Asking
Reduce Frequency
Real-World Example

Use AI for Understanding, Not Just Answers

When using AI assistants, it's important to prioritize learning over easy answers.

Instead of directly asking ChatGPT to answer a problem, ask it to explain the concept. This encourages learning and understanding.

Bad: "Write a function to sort a list in Python."
Good: "Can you explain how sorting algorithms work?"

Break Down Your Problem

Tackling complex problems piece by piece can prevent over-reliance on AI. Break your problem into smaller parts and try to solve each yourself. If you get stuck, ask ChatGPT about that particular issue. This way, you won't depend on the AI for the whole solution, just help in a specific part.

Bad: "I want to build a chat application. How do I do it?"
Good: "I'm having trouble setting up WebSockets for real-time communication in my chat application. Can you explain how WebSockets work?"

Ask for Resources, Not Direct Solutions

AI can help you find educational materials like documentation, articles, and tutorials.

For instance, ChatGPT can point you toward useful resources like documentation, articles, or tutorials. Going through these can give you a better understanding of your problem.

Bad (overly broad): "How do I create a web API with FastAPI?"
Good: "Can you recommend some good resources or tutorials to get started with FastAPI?"

Request Feedback

Another approach is to get AI feedback on your own work.

Rather than having ChatGPT generate a solution for you, come up with one yourself and get its feedback. You're doing the work, but AI is helping you refine and improve it.

Bad: "Write a SQL query to get the total sales from this database."
Good: "Here's my SQL query to calculate the total sales. Can you review it and suggest improvements?"

Use the Socratic Method

Chat with AI in an exploratory dialogue. Don't just get the answers; have a conversation to explore ideas further. Ask "why" often. This encourages better understanding.

Example:

You: "How does a linked list work?"
ChatGPT: "A linked list is a data structure in which elements, known as nodes, are connected by pointers. Each node contains data and a reference (or pointer) to the next node in the sequence."
You: "Why would someone choose a linked list over an array?"
ChatGPT: "Linked lists have several advantages over arrays... (and so on)."

Another example might be if you ask, 'How does a hash table work in Python?' as opposed to just accepting the explanation, follow up with 'Why is hashing used?' and 'How does hash table insertion improve lookup time complexity compared to a list?'. Asking clarifying questions will lead you to gain a deeper understanding.

Self-Reflect Before Asking

It's beneficial to reflect on your own process before using ChatGPT. Hence, take the time to explain the problem clearly, and consider it thoroughly.

Defining the problem can often help you find the answer.

Example:

Self-Thought: "I'm trying to filter this list, but the standard loop isn't efficient. Maybe there's a built-in function or a different data structure that's more efficient?"

If you haven't found the answer after thinking it over, then your question for ChatGPT will be more specific and focused.

Reduce Frequency

This part is hard, but you really want to be intentional about when you turn to AI. Set a personal rule for when you'll consult ChatGPT to help you stay persistent and build your problem-solving skills.

Consider what timeframe works for your learning style and current skill level. For instance:

If you're a beginner, limit AI use to only after you've spent 60-90 minutes thoroughly trying to solve a problem yourself. As a beginner, you likely need more time wrestling with new concepts yourself before seeking help.
If you have intermediate skills, perhaps 30-45 minutes of self-attempting is enough before consulting AI for hints.
If you're pretty advanced, maybe 15-30 minutes of self-attempting is sufficient before getting AI input. You likely can grasp new concepts faster, so minimize wasted time.

The exact minutes aren't important; get a decent mental workout, but don't burn out. The key is to challenge yourself based on your abilities. As you improve, reduce the time you allow before AI help. This pushes you to grow your skills and self-sufficiency. But have a limit to avoid unproductive struggles.

Finding the right timeframe takes some trial and error. If you frequently reach your time limit with no progress, extend it. If you rarely hit the limit, shorten it.

Real-World Example

Jane was new to Python and Django. She was building a simple blog site and got stuck setting up the URL routes. Rather than asking ChatGPT to write the routes for her, she asked it to explain Django URL routing and show examples.

After reading ChatGPT's explanation, Jane tried creating a few routes in her views.py file but got confused about the syntax. She asked ChatGPT specific questions about the route syntax as she coded, so she could understand how to structure them properly.

If you noticed, there was originally a mistake in this example, mentioning routes in views.py instead of urls.py; great catch! This was a small trick to demonstrate that AI, like ChatGPT, sometimes provides incorrect information. As helpful as AI can be, you should continue using your own critical thinking skills to identify potential errors. AI shouldn't be relied on 100% - stay focused, notice mistakes, and keep sharpening your own knowledge.

Conclusion

Combining these strategies into your learning can create a balance between relying on yourself and using AI tools. But hey, don’t feel you need to overhaul everything at once; it doesn’t have to be an all-or-nothing approach. Try out a suggestion or two, see what works for you, and build from there. Remember, the goal is always to understand, not just to get the answer.

Using tkinter with pyenv: A Simple Two-Step Guide

Max Shapira — Sat, 03 Jun 2023 09:14:37 +0000

I began a course taught by Christian Koch called "Learn Python by Building 10 Apps with tkinter". I soon realized I couldn't use tkinter even though it's a built-in Python module. Wait, what?

Traceback (most recent call last):
  File "/Users/maxshapira/Development/public/tkinter-basics/main.py", line 1, in <module>
    import tkinter as tk
  File "/Users/maxshapira/.pyenv/versions/3.11.0/lib/python3.11/tkinter/__init__.py", line 38, in <module>
    import _tkinter # If this fails your Python may not be configured for Tk
    ^^^^^^^^^^^^^^^
ModuleNotFoundError: No module named '_tkinter'

Well, if you use pyenv to manage your Python versions (which you should), you'll run into this issue. I spent a lot of time trying to figure out the right solution, so I wanted to share it with you.

Step 1: Installing Necessary System Packages

Using tkinter with pyenv can be tricky due to missing dependencies.

First, let's make sure we have installed the necessary system packages for tkinter.

In most Linux systems, you can install them with the following commands:

sudo apt-get update
sudo apt-get install tk-dev

On macOS, you can use Homebrew to achieve the same:

brew install tcl-tk

Step 2: Linking the Correct Tcl/Tk Versions

Next, make sure you link the correct versions of Tcl/Tk when installing Python. pyenv builds Python in your environment, but if you don't have the required dependencies, like the Tk/Tcl libraries, it'll build Python without them.

If the Python version you want to use is already installed on your system, you'll need to uninstall it before proceeding. For example:

pyenv uninstall 3.11.3

When installing a new Python version with pyenv, use the following commands:

For Linux:

sudo apt-get install -y make build-essential libssl-dev zlib1g-dev libbz2-dev \
libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev \
xz-utils tk-dev libffi-dev liblzma-dev python-openssl git

env PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install <version>

For macOS, after installing tcl-tk with brew:

brew install openssl readline sqlite3 xz zlib

env LDFLAGS="-L$(brew --prefix openssl@1.1)/lib -L$(brew --prefix readline)/lib -L$(brew --prefix sqlite3)/lib -L$(brew --prefix xz)/lib -L$(brew --prefix zlib)/lib -L$(brew --prefix tcl-tk)/lib" \
CPPFLAGS="-I$(brew --prefix openssl@1.1)/include -I$(brew --prefix readline)/include -I$(brew --prefix sqlite3)/include -I$(brew --prefix xz)/include -I$(brew --prefix zlib)/include -I$(brew --prefix tcl-tk)/include" \
PKG_CONFIG_PATH="$(brew --prefix openssl@1.1)/lib/pkgconfig:$(brew --prefix readline)/lib/pkgconfig:$(brew --prefix sqlite3)/lib/pkgconfig:$(brew --prefix xz)/lib/pkgconfig:$(brew --prefix zlib)/lib/pkgconfig:$(brew --prefix tcl-tk)/lib/pkgconfig" \
pyenv install <version>

Replace <version> with the version of Python you want to install. After that, you should be able to import tkinter in your pyenv Python environment.

Note that I couldn't get tkinter to work with pyenv on Python 3.11.0, but it worked perfectly on 3.11.2.

These steps should help you fix the tkinter and pyenv issue.

chill beats to focus to

Max Shapira — Wed, 31 May 2023 18:18:56 +0000

Focus.

We all want to find our focus and get into the zone. A great way to do that is with noise-canceling headphones and some relaxing music. Studies have shown that instrumental music such as classical, jazz, or ambient is best for relaxation and focus. Lo-fi beats are a great pick, as they don't have lyrics, and the tempo keeps you engaged without making you sleepy.

The South China Morning Post interviewed a psychologist who said that music, particularly lo-fi, can help block out distractions and keep you focused. He suggested sticking with slow, ambient tunes without lyrics, or at least those in a language you don't understand.

One study from Cardiff Metropolitan University adds some science to the mix. It found that listening to music you don't like can make you less productive, while your favorite tracks might also be distracting. The best bet is to go with music that you don't have strong feelings about either way.

When creating your own study playlist, here are some tips: make it ahead of time, keep it around 40-50 minutes long to remind you to take breaks, and avoid radio shows or anything with lots of talking. Also, don't crank up the volume too high - a moderate level is best. Lastly, try to stick with the same playlist to get used to the tunes and focus on your task.

I put in some effort to make a lofi mix with the right tracks and transitions between beats that will help you get focused and code your way to the top.

https://www.youtube.com/watch?v=2bPkFUnPf_w

Fire up your productivity: VS Code Themes to try right now (Updated)

Max Shapira — Fri, 21 Apr 2023 12:16:33 +0000

As programmers, we can be a bit obsessive-compulsive. It's not always bad, but sometimes it stops us from actually getting stuff done. And what's that stuff, you ask? Well, it's coding. Of course, we spend much time reading code too, but real learning happens when we dive in and start typing.

When we were coding newbies, any old default dark theme would do the trick. But as we get more experienced, we get insanely choosy in our workspace. I bet you can relate to the thoughts that go through our heads when we're trying to pick a new theme:

"This one doesn't have enough contrast."
"Doesn't support Python syntax? No thanks."
"Too dark."
"Too bright."
"Too colorful."
"Too ugly."

It's a real headache. We waste so much time trying to find the "perfect" theme, only to return to our old favorite theme. Don't get me wrong, finding the right theme can increase productivity, creativity and be a fun way to connect with other coders. But balancing the search for the "perfect" theme with actual work is essential to avoid getting distracted and losing focus on what truly matters - achieving success!

I've rounded up some of the most sophisticated themes out there so you can focus on what really matters. You don't need to scroll through countless options; I've got you covered.

1) oh-lucy

2) Dark++ Theme

3) Community Material Theme

4) Min Theme

5) Flate

6) Horizon Theme

7) Atom One Dark Theme

8) Honorable mention: joey

Why is joey theme an honorable mention? It's because it's my jam! I took a solid theme, and after three years of tinkering, I ended up with a theme that helps developers focus like a ninja. I won't strong-arm you into using it and say, "You have to use it!" because it's about personal preference. But you should give it a shot. If it works for you, then I've done my job.

Recap

Code time, tune in, zone out!

Mastering Functions: How to Write Functions That Will Take Your Skills to the Next Level

Max Shapira — Sat, 15 Apr 2023 14:09:31 +0000

I'm on the verge of finishing a great course called "Clean Code" by Maximilian Schwarzmüller.

I stumbled upon the concept of writing good and clean functions and wanted to share some valuable principles which will be especially handy for beginners. So you can see this blog post as an informative summary of that course section.

Let's dive in by looking at eight main points:

Functions are like little helpers in our code that we can repeatedly use to do something specific.
A good function should only do one thing. It shouldn't be trying to do too much all at once.
We can also think about levels of abstraction, which means how high or low we are in terms of how much detail we deal with.
High-level operations are like big-picture ideas that we can express with a few words or phrases, while low-level operations are more detailed and specific.
A good function should only be responsible for work that is one level of abstraction below its name. This means that if the function has a descriptive name, it should only deal with operations that are one level more detailed than that name suggests. Use verbs or short phrases with adjectives to name functions correctly (e.g., send_data)
When we write a function, we should give it a descriptive name that tells us what it does.
If a function is doing too much, we can break it down into smaller functions that each does one specific thing.
By breaking down functions into smaller pieces, we can make our code easier to understand and maintain.

Consider this simple function that calls collect_coin and adds 1 to the player's coin count.:

def collect_coin(player: dict) -> None:
    player['coins'] += 1

Here's an example of a lousy function that's trying to do too much:

def play_game(player: dict, enemies: list, walls: list) -> None:
    for enemy in enemies:
        if player['rect'].colliderect(enemy['rect']):
            player['hitpoints'] -= 1
            if player['hitpoints'] == 0:
                player['game_over']()
    for wall in walls:
        if player['rect'].colliderect(wall['rect']):
            player['move_back']()
    player['coins'] += 1

The function calls play_game, which checks for collisions with enemies and walls, adjusts the player's hitpoints and coin count, and even ends the game if the player's hitpoints reach zero.

To illustrate, we can fix the play_game function by breaking it down into smaller functions that each does one specific thing.

def check_for_enemy_collision(player: dict, enemies: list) -> None:
    for enemy in enemies:
        if player['rect'].colliderect(enemy['rect']):
            player['hitpoints'] -= 1
            if player['hitpoints'] == 0:
                player['game_over']()

def check_for_wall_collision(player: dict, walls: list) -> None:
    for wall in walls:
        if player['rect'].colliderect(wall['rect']):
            player['move_back']()

def collect_coin(player: dict) -> None:
    player['coins'] += 1

def play_game(player: dict, enemies: list, walls: list) -> None:
    check_for_enemy_collision(player, enemies)
    check_for_wall_collision(player, walls)
    collect_coin(player)

Side Note:

rect and colliderect are attributes and methods of a Rect object, which is a built-in class in the pygame module used for handling rectangular areas.

So, the expression player.rect.colliderect(enemy.rect) checks if the player is hitting the enemy by comparing the position and size of the two objects using the colliderect method.