DEV Community: OdyAsh

Why RSS Feeds Are Useful

OdyAsh — Sat, 31 May 2025 08:05:21 +0000

🎯 The aim of this post is to provide an example on why you should incorporate RSS feeds in your daily routines :].

🔎 When trying to get up-to-date with Python's current landscape, I often find "articles going over trivial (but still useful) things" [1], so I try to tailor my RSS feed to give me news from on-the-ground devs.

💡 One great example I found is Edward Li. He just started posting recently [2] [image-1], but he tackles deep-tech topics/ideas with an easy-to-understand writing style, which is a goldmine in the AI-generated slop ecosystem we live in nowadays [3].

🔖 Therefore, I suggest adding his blogs to your RSS feed! 🙌 [footnote-1] [image-2]

[footnote-1]: Check this 1-min. video if you don't know what an RSS is: https://lnkd.in/dpqG_3AU , then get one of the RSS apps that sync between your PC/mobile for easy access. My suggestion: feedly app. [image-2] is taken from feedly.com.

[1]: this was actually a quote I took :] from one of his articles: https://lnkd.in/dpN3-HqP
[2]: Edward Li's blog page: https://lnkd.in/dgsYnxxu
[3]: Article on AI-Slop Destroying the Internet: https://lnkd.in/dDCEpQ8g

[image-1]:

[image-2]:

Surviving The Vibe Coding Trend

OdyAsh — Sun, 11 May 2025 16:32:55 +0000

TOC:

"Why Should I join CS When Code Can Be Easily Vibed 🏄‍♂️ ?"
- "Problem Complexity? Huh?"
- "Ok, So Does The AI Vibe ✨ With All of These Levels?"
"What You're Saying is a Little Bit Abstract. Examples, Plz?"
- First - Strategic Thinking (lvl1)
- Next - Technical Decision Making (lvl2)
- Then - Tactical Problem Solving (lvl3)
- Finally - Function Implementation (lvl4)
- Final Product
- Lessons Learned From This Journey
Footnotes and References
If you Have Any Questions/Suggestions...
And If I made a mistake

This post acts a survival guide for devs. (with a focus on CS students) who are currently in the middle of the "Vibe Coding" wave 🌊. [1]

Actually, I'll phrase this post in a question-answer format while assuming that you are a pessimistic dev. who is not vibing with the current AI trends.

"Why Should I join CS When Code Can Be Easily Vibed 🏄‍♂️ ?"

First of all, what "code" are you talking about?

You "code" to accomplish a "task". I.e., a "problem" that you want to solve.

These problems can be categorized into multiple levels of complexity ...

"Problem Complexity? Huh?"

Yes, here's a simple categorization of the problems that any developer faces in terms of complexity/scope [fn.1]:

(Shown in this order: lvl1 -> lvl2 -> lvl3 -> lvl4)

Details of each level [fn.1]:

(Explained in this order: lvl4 -> lvl3 -> lvl1 -> lvl2)

Simple isolated problems (lvl4): These are the problems that can be usually solved using a single function.
1. For example, reading an audio file from a local file path into RAM.
Complex isolated problems (lvl3): These are the problems that can be solved using a workflow of multiple logically-connected steps. Usually, in a series of function calls.
1. For example, downloading audio files from a website, concatenating them, and then converting them to a single audio file.
2. Concretely, a lvl3 problem can be broken down to lvl4 problems that are connected together.
Abstract connected problems (lvl1): These are big picture problems by understanding the big picture of a system. These are the problems that made you want to develop the system in the first place.
1. Also known as: "high level design (hld)" / "system design" / "system architecture".
2. For example, a system that allows users to get audio files from a website, then download them as a single audio file.
3. These are "solved" by having a mental model of:
  1. The exact requirements of the system (i.e., the problem).
  2. The system architecture (i.e., the solution). E.g., "a web app, where the frontend requests the audio files, and backend processes them, and then returns the final audio file to the frontend".
  3. Optionally: We create a prototype with placeholders for the functions that we will implement later (just to mentally visualize the flow of the system).
Concrete connected problems (lvl2): These are the problems that are solved by specifying the details of the system architecture then implementing them.
1. Also known as: "low level design (lld)"."
2. E.g., react/fastapi for frontend/backend, streamlit for both, etc. python as main language, uv for managing dependencies, etc.
3. Concretely, a lvl1 problem is basically a series of lvl3 problems that are connected together.

"Ok, So Does The AI Vibe ✨ With All of These Levels?"

Let's visualize how our brains process these different problem levels and when AI assistance is most effective:

Side note: Open the above image here if it's appearing blurry on dev.to

Now let's break it down:

(In this order: lvl4 -> lvl3 -> lvl1 -> lvl2)

For lvl4 problems: Yes, AI can easily vibe with them.

For lvl3 problems: Usually, yes. But...
1. If the problem is related to a tech stack that the AI is not familiar with, then its vibeage will be limited.
  1. E.g., if you ask the AI to write a function that uses a library that it doesn't know about.
  2. This can be mitigated by providing the library's docs yes... but this will not always be a possible option. Examples:
    1. Library has outdated docs.
    2. Library has no docs at all.
    3. Library is not open-source, so you can't even clone it and tell AI to read it.
    4. etc.
2. If you phrase your request in a very strict way, then the AI could overcomplicate the solution.
  1. E.g., you ask AI to do A/B/C to get D, but if you've just asked it to do D, then it would have done it in a simpler away.
    1. I.e., under-trusting your AI buddy :[.
3. If you phrase your request in a very vague way, then the AI could over-simplify the solution while neglecting important corner cases.
  1. E.g., you ask AI to return D, but you forgot to mention that D should be in a specific format, or that it should be sorted in a specific way, etc.
    1. I.e., Over-trusting your AI buddy :[.

For lvl1 problems: depending on the complexity of the problem you're trying to solve:
1. For commonly known problems (e.g., "write a full web-based todo app"), it can provide a big picture solution (e.g., it will whip up a possible system architecture for you).
2. For less commonly known problems, the provided big picture solution will be less accurate than the previous example.
  1. E.g., if you want to create a app for Islamic prayer times, then it might propose using an outdated GitHub library that calculates prayer times offline, even though your solution might be better off using an online API service instead.
  2. Well then how do you know which system architecture is more well suited?
    1. You look at your requirements and constraints. For example, if you know that this prayer times app will be mostly working offline, then prefer a calculation library over an online API service, etc.
  3. Therefore, you need to have a good understanding of the problem you're trying to solve, and the requirements/constraints of the system you're trying to build.
    1. This is where your CS knowledge comes in handy! :]
  4. Then and only then can you ask the AI to help you with the big picture solution.

For lvl2 problems: Similar situation to lvl1 problems;
1. If you just give it a high level design (i.e., a lvl1 solution) and tell it to suggest the suitable tech stack and provide detailed implementation without giving it proper requirements/constraints/context, then it may choose libraries that are not suitable for your use case down the road.
  1. For example, in the prayer times app, it may suggest an API library that has a monthly limit of 1000 requests, while your app may need to make 2000 requests per month, etc.
  2. Well then how should you have tackled this problem?: By having a prior experience on using APIs, so that you can ask questions like "API's rate limit?", "API's server availability?", "API's response time?", etc., and accordingly have an explicit requirement/constraint for the AI to work with.

"What You're Saying is a Little Bit Abstract. Examples, Plz?"

Let me map these levels using a real project I recently built: ayahs-audio-downloader - a tool that downloads and concatenates Quranic audio verses.

First - Strategic Thinking (`lvl1`)

My journey started with a high-level problem: "I want to create a tool that lets users select a range of Quranic verses, download their audio files, and combine them into a single file."

In my initial prompt, I wrote:

"I input an ayah range (e.g., 2:2 - 2:8), then that API gives me these ayahs with audios, and I then concatenate them together to a single audio file."

I was thinking at the highest abstraction level - what the system should accomplish, not how it would work.

Next - Technical Decision Making (`lvl2`)

After exploring available APIs, I made architectural decisions:

Use the Quran API for audio files
Build a Streamlit web application for the interface
Structure the project with separate modules for downloading and processing
Use Python with uv for dependency management
Include FFmpeg via packages.txt for Streamlit Cloud deployment

I outlined these requirements in detail:

"3.1 The user chooses the starting ayah (e.g., 2:1) and the ending ayah (e.g., 2:8)
3.2 the user then chooses the reciter of choice...
3.3 the user clicks on get audio file..."

Then - Tactical Problem Solving (`lvl3`)

Next, I broke down the main functionality into discrete problems:

Downloading audio files for a range of verses
Concatenating audio files into a single MP3
Handling the UI flow with Streamlit

Each of these needed a specific implementation strategy. For example, the audio concatenation process required:

Loading each audio file with PyDub
Joining them sequentially
Handling errors if any file failed to process

Finally - Function Implementation (`lvl4`)

At the lowest level, I had individual functions like:

parse_ayah_reference() - Parse an input like "2:5" into surah and ayah numbers
get_reciter_id_by_name() - Map reciter names to their IDs
download_ayah_audio() - Download a single audio file
generate_output_filename() - Create a standardized filename

These are simple, isolated functions that each do one thing well.

This workflow - starting with the big picture (lvl1), making architectural choices (lvl2), breaking it into major components (lvl3), and finally writing individual functions (lvl4) - represents a much more efficient approach than jumping straight to coding without proper planning.

Final Product

The Streamlit 👑 app can be accessed here: https://ayahs-audio-downloader.streamlit.app/

App demo:

App's architecture:

(source)

Lessons Learned From This Journey

Importance of Planning: If I had taken more time to plan the project, I could have avoided some of the pitfalls I encountered. Examples:
1. I didn't think which audio-processing library I should choose. Instead, I relied on the AI model (i.e., copilot) to suggest one for me.
  1. It chose pydub which is a great library, but it internally uses ffmpeg, which isn't a python library. So I had to install it separately.
  2. If I had just thought about it, I would have realized that most audio-processing libraries use ffmpeg under the hood anyways, so I would've indicated to copilot a new constraint:
    1. "I want to use a library that doesn't require any external dependencies".
    2. Or: "I'm later uploading this to streamlit cloud, so read the streamlit docs to see how it handles external dependencies and act accordingly"
    3. Etc.
Think of Dependencies That The AI Might Want to Know About: Examples:
1. Stating that the solution will be eventually deployed to streamlit cloud would have helped copilot act accordingly on how to install ffmpeg.
2. Stating that the solution will use Python 3.13 could have helped copilot choose libraries that are compatible with it.
  1. For example, it chose pydub, which turned out to have issues with Python 3.13, so I had to downgrade to 3.11.
  2. However, I'm skeptical about this tip. I.e., I'm skeptical that copilot is trained enough to know that certain python libraries have issues with certain python versions. So I wouldn't rely on this tip too much.
Ride The Vibe Tech Wave: There is so many tools/websites out there that can help you with your workflow/docs. Examples:
1. GitHub Copilot: Enough said.
2. Deep Wiki: A website that indexes your public GitHub repos and provide nice docs for it.
  1. E.g.: https://deepwiki.com/OdyAsh/ayahs-audio-downloader
3. Generate mermaid diagrams with AI.
  1. Details: Medium article.
  2. Even the diagrams in this article are generated using mermaid :].
4. SpecStory Extension: An IDE extension that tracks/saves your conversation's with the IDE's AI model (e.g., copilot).
  1. For example, check out the markdown files here to see how I made this article ;].
5. Use AI as your "friendly neighbourhood plumber" [2].
  1. Updated your codebase and now you're dreading the README.md and docs/*.md documentation? Just ask the AI to do it for you.
  2. Need to manually change file references? Let the AI create a VSCode task that will automatically do this for you <3.
  3. and so on...
  4. See the pattern here? The 2 problems above are lvl2, so prompt the AI succinctly, and the AI will return a mostly working solution :].
Just Because You Can Vibe, Doesn't Mean You Should:
1. I did some problem-solving by myself (e.g., lvl3, parts of lvl4).
2. Yet, I still relied on the AI for most of the implementation (e.g., majority of lvl4, which is a series of lvl2/lvl1 problems that the AI defined and solved).
3. However, what helped me is that I already had a mental big picture on how a problem like this can be solved and what tech stack is suitable for it.

What I'm trying to say is this: Only when you're comfortable with problem solving, system designing, and experiencing different tech stacks hands-on, then you can start relying on the AI to do the vibing for you 🏄‍♂️✅:

Otherwise, you will be lost in the middle of the vibe waves, and you won't know how to swim back to shore 🏊‍♂️❌:

Footnotes and References

[fn.1]: These levels of complexity are completely subjective, and they are not based on any scientific research. They are just a way for me to mentally categorize a problem when I see it.

[1]: Cover art by Pete Sena: "Cracking the code of vibe coding" medium article. Side logos by flaticon.com (computer science, problem solving)

[2]: The Bulk of Software Engineering is Just Plumbing, by Karl Hughes

If you Have Any Questions/Suggestions...

Your participation is most welcome! 🔥🙌

And If I made a mistake

Then kindly correct me by:

Writing a comment ✍️
Or opening a PR on GitHub
- Details

See ya! :] 🙌

From LocalHost to Public Endpoint - Quickly Share Your Work With zrok

OdyAsh — Sat, 30 Nov 2024 13:26:50 +0000

TOC:

Use Case
Install zrok to Your OS
Create an Account
See The Initial UI of zrok
Connect Your Device with Your Account
The Magical Part - zrok Reserve and Share
- Later Runs
Important Advice
If you Have Any Questions/Suggestions...
And If I made a mistake

Use Case

Suppose you're using a web server framework like uvicorn to run your backend service locally (e.g., on http://localhost:8000)

Ok, but that http://... is a local URL... So how do we share it publically instead of locally?

Use zrok! 🌌

(Side note: Check the first 2 paragraphs here for a more eloquent explanation of when to use zrok :])

Install zrok to Your OS

Based on your Operating System (OS), follow the steps in the guide page reached from here.

When you're done, executing zrok -h in a terminal should give you the list of commands that you can run using zrok!

Side note 1: Regarding Windows users, the commands written in their guide page are executed via powershell.

Side note 2: Personally, I just get the zrok.exe file, add it to the repository's root folder, add zrok.exe to .gitignore, then run zrok commands in the terminal instead of adding zrok to windows' PATH variable... however, that solution is a workaround, and should not be standardized :]

Create an Account

Create an account by doing the following:

Visit zrok's getting started page here.
Click on "Get an Account" under "Hosted zroknet".
Click on "sign up" at the bottom of the form.
Fill in your credentials then click sign up.
You'll then be redirected to https://myzrok.io/settings, where you'll fill in the same credentials
1. (again ಠ_ಠ)
Click SAVE, then you'll be presented with this command: zrok enable yOUrPriVaTeToken, store this command carefully in a notepad or something, we'll need it soon.
Then login to https://api.zrok.io/ by using your credentials...
1. (again! (╯°□°）╯︵ ┻━┻ )
Done!

Side note: You could've also partially done this via terminal, as shown here

See The Initial UI of zrok

Upon successfully logging in, you'll see the https://api.zrok.io/ page looking like this:

Now, you can use NetFoundry's public zrok instances to share your web server! Let's see how...

Side note: If you click on the 🔽 icon next to your email, then click on Enable your environment, you'll see the command that I told you to store in a notepad :].

Connect Your Device with Your Account

Run the zrok enable yOUrPriVaTeToken command in your terminal to connect your account with your device.

Then, read the entire Enabling Your zrok Environment section from the official docs here, as it explains the above command, and then shows you what the UI of api.zrok.io should now look like.

The Magical Part - zrok Reserve and Share

Now for the good part, assuming you are currently running your backend server, e.g., something like this (IDE is VSCode btw):

Then, you'll open another terminal, like so:

Then, execute this command:

zrok reserve public localhost:8000 -n youruniqueinstancename

If you don't change the last argument above (which is called a share token), the final frontend URL will appear like this: https://youruniqueinstancename.share.zrok.io, as can be seen here:

As you noticed from the screenshot above, a connection has been reserved with the token name that you used in the last argument of the aforementioned command,and is now configured to eventually bind with your localhost URL.

To make it actually bind with your localhost, run this final command:

zrok share reserved youruniqueinstancename

Now, if we try to send requests using any online REST client tool, e.g., restninja:

You'll see the terminal returning this output:

Which means we can now share this public URL for quickly testing and/or displaying our work with others!

Side note: To terminate the session, hit ctrl+c (windows) or close the terminal from here (still in VSCode):

Tricky note: the youruniqueinstancename token is globally unique. In other words, if a developer "Bob" currently hosts a zrok public URL with this token, and a developer "Steve" simultaneously tries to create a public URL with that exact token, it won't work (will give you a shareConflict error).

Later Runs

In future terminal sessions, it's sufficient to run zrok share reserved youruniqueinstancename to start a new session of binding public zrok URL with localhost :].

Important Advice

I highly suggest fully reading zrok's getting started page, then all the sub-pages under concepts, as they greatly explain the when/where/how's of zrok.

If you Have Any Questions/Suggestions...

Your participation is most welcome! 🔥🙌

And If I made a mistake

Then kindly correct me :] <3

Tokens vs Chunks

OdyAsh — Sat, 14 Sep 2024 13:09:01 +0000

Tokens vs Chunks

When reading articles or documentations, you'll see that sometimes, "tokens" and "chunks" are treated as synonyms, but usually they represent different granularity levels. Demonstration by definitions:

Tokens

A token is the smallest unit of data that the NLP model processes, such as a sentence, a word, or a character (s1).
It's a way to break down and analyze text into manageable components (s2).

Chunks

A chunk is a group of tokens (s3)
For example, if we have this text: "Hello there! My name is OdyAsh (new paragraph) I like astronomy!", then depending on how you want to process this text, you might have one of these configurations:
- tokens ⟺ sentences, chunks ⟺ paragraphs
- tokens ⟺ words, chunks ⟺ sentences
- tokens ⟺ words, chunks ⟺ group of nouns only (i.e., process the tokens so that they are grouped into chunks of noun phrases. Example: s4.
- tokens ⟺ characters, chunks ⟺ words
- tokens ⟺ characters, chunks ⟺ chunk size (i.e., 200 characters)
- Examples: here: s5

So, one might treat a chunk as a unit of data which the NLP model gains useful info from (s4), and by chunking down, we get to the details of each chunk, i.e., the tokens which form this chunk (s6).

Summary

Usually:
- A chunk: a unit of data with a low granularity level.
- A token: a unit of data with a high granularity level.
Occasionally:
- They are treated as the same thing.

If you have any questions/suggestions...

Your participation is most welcome! 🔥🙌

And If I made a mistake

Then kindly correct me :] <3

Sources

Learning Spark 2.0 Knowledge Dump

OdyAsh — Mon, 29 Apr 2024 08:00:19 +0000

This post will serve as a continuous knowledge dump regarding the "Learning Spark 2.0" book, where I'll dump certain quotes that I find relevant (and hopefully you will too :]!)

In Spark’s supported languages, columns are objects with public methods (represented by the Column type).

Code example that uses expr(), withColumn, and col():

blogsDF.withColumn("Big Hitters", (expr("Hits > 10000"))).show()

The above adds a new column, Big Hitters, based on the conditional expression, noting that expr(...) part can be changed with: col("Hits") > 1000.

In Scala, using the dollar sign $ before a string will be rendered as a function which converts this string into type Column. Details can be found here

In Spark, a Row is a Spark object which consists of an ordered collection of fields. Therefore, you can access its fields by an index starting from 0.

Parquet does not support some symbols and whitespace characters in column names (source).

Check the PySpark date and time functions here. Check this docs for all pyspark's SQL-related functions. Finally, check Spark SQL's built-in functions that are equivalent in definition here. For example, "=" and "==", "!=" and "<>".

From the book: The DataFrame API also offers the collect() method, but for extremely large DataFrames this is resource-heavy (expensive) and dangerous, as it can cause out-of-memory (OOM) exceptions. Unlike count(), which returns a single number to the driver, collect() returns a collection of all the Row objects in the entire DataFrame or Dataset. If you want to take a peek at some Row records you’re better off with take(n), which will return only the first n Row objects of the DataFrame.

DSL operators means Domain-specific language operators

"Datasets" -> Java/Scala (as they're compile-time/type-safe languages)
"Dataframe" -> Python (as types are dynamically inferred/assigned during execution)
Tricky note: "Dataframe" -> Scala (because in Scala, a DataFrame is just an alias for untyped Dataset[Row])
- A Row is a generic object type in Spark, holding a collection of mixed types that can be accessed using an index.
- Example of defining a Scala Case Class to use DeviceIoTData instead of Row can be found here

Summary of the above bullet points:

When we use Datasets, the underlying Spark SQL engine handles the creation/conversion/serialization/deserialization of JVM objects as well as Java heap memory management with the help of Dataset encoders.

DataFrames Versus Datasets:

Use Datasets if you want:
- strict compile-time type safety and don’t mind creating multiple case classes for a specific Dataset[T].
- Tungsten’s efficient serialization with Encoders.
Use Dataframes if you want:
- SQL-like queries to perform relational transformations to your data.
- unification, code optimization, and simplification of APIs across Spark components, use DataFrames.
- an easy transition from R language.
- to precisely instruct Spark how to do a query using RDDs.
- space and speed efficiency.

How to Create Documentation of Multiple .py Files using Pdoc

OdyAsh — Mon, 19 Feb 2024 12:35:27 +0000

Problem Statement

Suppose your project's directory structure is like this:

- proj_root_dir
  - module_py_files_dir
    - general_functions.py
    - util_class.py
  - runnable_py_files_dir
    - main.py
  - documentation (optional, as pdoc creates it anyway)

And suppose you want to create documentation for the functions/modules found in module_py_files_dir.

Now, the solution is mentioned in the following sections.

Assuming You Created `virtualenv` Environment

If you've created a virtual environment for proj_root_dir, then first make sure that the pip currently selected is related to that environment by running:

pip -V

If not, make sure to select the Python interpreter related to the desired virtual environment (steps to do so on VSCode are here)

Side note: if you don't make sure you're using the right virtual environment, you may receive a ModuleNotFound error when trying to run the pdoc command later on.

Assuming You Created `conda` Environment

If you're dealing with Conda, then you will have one of two scenarios:

Either you use pip install or conda install. If you're using the former, then run the pip -V command as in the previous section.

In either case, you should then run conda info --envs and see which path is prefixed with *. If it the path of the conda environment you created, then you're good. If not, then you need to run conda activate PATH_TO_YOUR_ENV_FOLDER first.

Installing `pdoc`

Apparently, pdoc is not officially maintained by conda, so we'll just mention the pip installation command:

pip install pdoc3

That means that even if you have conda, it will use the pip package manager (inside of conda) to install pdoc, this is not considered best practice.

Running `pdoc`

Assuming the project directory structure mentioned in the first section of this post, the run command looks like this (adapted from this article):

pdoc --html "module_py_files_dir" --output-dir "documentation"

the --html command recursively searches for all .py files present in module_py_files_dir and converts them to .html pages found in documentation directory.

Caveats

What if for some reason, we have functions present in the main.py that we want pdoc to document as well? In that case, one of two scenarios will have happened:

Either you implemented the if __name__ == "__main__" guard, or you didn't.

Either way, pdoc should be run successfully, but be aware that pdoc runs the .py files, so if you didn't place that guard, then the code that should've been inside that guard will run, so ask yourself if this is something you want or not.

Outro

Hit me up if you have any questions ^^ 🙌:
LinkedIn
GitHub
Gmail: ashicsresources@gmail.com

But for now...

"Unable to Open IPYNB... Bad Control..." Fix

OdyAsh — Wed, 14 Feb 2024 07:00:09 +0000

Problem Statement

When you finish working on a Jupyter Notebook (.ipynb) file, sometimes, it might not be saved in a correct state, so when you later open the file, you see an error which states "Unable to open x.ipynb. Bad control character in string literal in JSON at position y (line w column z)":

Solution

Solution (taken from this SO answer):

Open the file by clicking on the Open in Text Editor option shown in the screenshot above.

Then see which lines are causing syntax errors:

Then, make sure these lines end with \n:

As you can notice by the highlighted lines in yellow, I had duplicated the line ipython = get_ipython()\n in the wrong place, which was the cause of the error.

A Tip on How to Search for Errors

Initially, I searched for the error like this:

As you can see, the initial results weren't helpful. Moreover, when I asked ChatGPT 3.5 on this error (with minimal prompt engineering), it gave me this result, which wasn't very useful for my case:

However, when I modified my search term to be like this:

It gave me the SO post that solved my issue!

TLDR; knowing small search tricks can save you some time :].

Bonus - `autoreload`

If you're curious about the context of the code in the screenshots above, check this file :].

Outro

Hit me up if you have any questions ^^ 🙌:
LinkedIn
GitHub
Gmail: ashicsresources@gmail.com

But for now...

Why I Don't Write Posts

OdyAsh — Mon, 12 Feb 2024 11:32:58 +0000

The Vicious Loop
Personal Example
How to Break Out of This Loop?
Conclusion

The Vicious Loop

You won't believe how many times I've had ideas for articles/blogs to write about but don't follow through with writing them due to the perfectionism-imposter loop:

Fig.1 - The perfectionism-imposter loop (from now on, source will be hyprlinked above).

Personal Example

I want to write a blog about how I've found a way to easily share/pass global variables across multiple python files.
I realize that the notes I've done for this are not polished enough for a blog post.
I tell myself that I won't publish anything unless I completely prepare the notes and the structure of the blog (perfectionism).
I don't return to these notes, as the burden of polishing what I wrote is too big, so I end up not publishing anything (procrastination)
When and if I decide to return to the notes/blogs, I overwork myself with very small details, such as spending 10 minutes to find that I can write   to leave some space between paragraphs (over-functioning):

Fig.2 - Example of perfectionism/overfunctioning).
After I finish writing the blog, I contemplate how I took so long to write something that's not polished enough like other blogs I see (imposter syndrome).
So, I decide that future posts will be more polished (perfectionism).
Thus, the loop, continues.

How to Break Out of This Loop?

Just, write the post.

Just, finish your work, even if it's not polished enough.

Just, share your work, even if others have done "better" work than you; You do this for yourself, and because you believe someone might benefit from what you write, not because you want to show off and compare yourself with others who've written "better" blogs.

TLDR:

Conclusion

This post serves as a way for me to break this vicious cycle and as an encouragement to write about my findings throughout my learning journey one day :].

Let me know what you think, and what prevents you from writing posts <3.

DEV Community: OdyAsh

Why RSS Feeds Are Useful

Surviving The Vibe Coding Trend

"Why Should I join CS When Code Can Be Easily Vibed 🏄‍♂️ ?"

"Problem Complexity? Huh?"

"Ok, So Does The AI Vibe ✨ With All of These Levels?"

"What You're Saying is a Little Bit Abstract. Examples, Plz?"

First - Strategic Thinking (lvl1)

Next - Technical Decision Making (lvl2)

Then - Tactical Problem Solving (lvl3)

Finally - Function Implementation (lvl4)

Final Product

Lessons Learned From This Journey

Footnotes and References

If you Have Any Questions/Suggestions...

And If I made a mistake

From LocalHost to Public Endpoint - Quickly Share Your Work With zrok

Use Case

Install zrok to Your OS

Create an Account

See The Initial UI of zrok

Connect Your Device with Your Account

The Magical Part - zrok Reserve and Share

Later Runs

Important Advice

If you Have Any Questions/Suggestions...

And If I made a mistake

Tokens vs Chunks

Tokens vs Chunks

Tokens

Chunks

Summary

If you have any questions/suggestions...

And If I made a mistake

Sources

Learning Spark 2.0 Knowledge Dump

How to Create Documentation of Multiple .py Files using Pdoc

Problem Statement

Assuming You Created virtualenv Environment

Assuming You Created conda Environment

Installing pdoc

Running pdoc

Caveats

Outro

"Unable to Open IPYNB... Bad Control..." Fix

TOC

Problem Statement

Solution

A Tip on How to Search for Errors

Bonus - autoreload

Outro

Why I Don't Write Posts

Table of Contents

The Vicious Loop

Personal Example

How to Break Out of This Loop?

Conclusion

First - Strategic Thinking (`lvl1`)

Next - Technical Decision Making (`lvl2`)

Then - Tactical Problem Solving (`lvl3`)

Finally - Function Implementation (`lvl4`)

Assuming You Created `virtualenv` Environment

Assuming You Created `conda` Environment

Installing `pdoc`

Running `pdoc`

Bonus - `autoreload`