These experiences have shaped my understanding of what true innovation looks like. It’s not just about the initial spark of a brilliant idea—though that’s important—but about the entire ecosystem that supports and nurtures that idea into something world-changing. It’s about the collaboration between different actors, the willingness to revisit and reinvent, and the open exchange of resources, knowledge, and opportunities.

And now, after years of refining this approach, I’ve found what I believe to be the utopia of innovation: Venture Grid.

What is Venture Grid?

Venture Grid is more than just a concept; it’s a revolutionary approach to how we build and scale businesses. It’s a dynamic, interconnected ecosystem where the boundaries between innovation, incubation, funding, and growth strategy blur, creating a fluid environment where ventures can thrive.

In the Venture Grid, every actor—whether it’s a startup, an established company, a venture capitalist, or an innovation lab—loses their traditional boundaries and collaborates in a seamless, risk-taking environment. Here, ideas that once struggled alone find new life through strategic mergers. Failed startups are not abandoned but reimagined, combined with other ventures, or infused with fresh innovations sourced through open challenges and collaboration.

Why Venture Grid?

Through my work with venture builders and factories, I’ve seen firsthand the challenges of scaling innovative ideas. Often, brilliant concepts fall short because they don’t have the right resources at the right time or because they can’t pivot fast enough to meet changing market demands. Venture Grid changes that by creating a space where:

• Synergies Are Discovered: Ventures within the grid collaborate, merge, and evolve. A failed tech startup might combine with a logistics firm to create something entirely new, stronger, and more viable.

• Open Innovation Thrives: External ideas and technologies are welcomed into the grid, where they can be rapidly tested, refined, and scaled. This open approach breaks down silos and ensures that the grid is constantly infused with new possibilities.

• Resources Are Shared: The grid’s structure reduces the cost of scaling by providing shared services, from legal support to advanced technological infrastructure. This makes it easier for ventures to grow without the burden of excessive overhead.

• Continuous Learning and Adaptation: In the Venture Grid, we never stop learning. Mentorship, training, and access to the latest technologies are integral parts of the grid, ensuring that every actor can adapt and thrive in a rapidly changing world.

My Journey to the Venture Grid

My journey to this concept has been a path of discovery. I’ve watched ideas evolve, pivot, and sometimes fail, only to be reborn stronger. I’ve seen the incredible things that happen when resources are pooled, when risks are shared, and when the walls between different parts of the innovation process come down. It’s in these moments that I realized the potential of a truly interconnected ecosystem.

Venture Grid is the realization of this potential. It’s where I’ve seen ideas that were once isolated and struggling find their perfect complement in another venture. It’s where I’ve witnessed the power of open innovation—how an idea from one corner of the world can transform a business on the other side of the grid. And it’s where I believe the future of innovation lies.

A Call to Action

I invite you to explore the Venture Grid with me. Let’s challenge the traditional boundaries of innovation, embrace collaboration, and take risks that push us into new territories. Whether you’re a startup looking to grow, a company seeking to innovate, or an investor searching for the next big thing, there’s a place for you in the grid.

Together, we can create a new world of innovation where ideas don’t just survive—they thrive, evolve, and change the world.

Welcome to the Venture Grid.

I am Ali, a Grid Smith.

The Journey Back to Pychartjs

Several years ago, I inherited pychartjs—a Python library designed to generate dynamic charts using Chart.js. While the library had a strong foundation, it had become outdated over time, and I knew it needed a refresh to stay relevant in the rapidly evolving Python ecosystem. With the growing demand for versatile and modern tools, I decided it was time to bring pychartjs up to date and make it more flexible for developers across various frameworks.

What’s New in Pychartjs

1. Framework-Agnostic Design

One of the major changes I’ve implemented is making pychartjs framework-agnostic. No longer confined to a specific web framework, pychartjs can now be integrated seamlessly into any Python web framework—whether it's Django, Flask, FastAPI, Robyn, or any other WSGI/ASGI framework. This opens up the library to a much broader audience and allows developers to choose the framework that best suits their needs without sacrificing charting capabilities.

2. Flexible Render Options

Another key feature of the update is the introduction of flexible render options. With the new rendering capabilities, developers can customize how charts are generated and displayed within their web applications. Whether you need to render charts dynamically based on context variables or generate static charts for reports, pychartjs now provides the tools to do so with ease.

3. Seamless Integration with Any Python Web Framework

Understanding the diverse needs of the Python web development community, I've updated pychartjs to integrate smoothly with any Python web framework. Whether you're using traditional frameworks like Django or Flask, or newer, faster options like FastAPI and Robyn, pychartjs is designed to fit right in. Its framework-agnostic approach means you can use it with any HTML rendering engine, such as Jinja, Mako, or your framework's built-in options.

Robyn and Beyond

Robyn, a relatively new but fast-growing web framework, is fully supported by pychartjs. You can easily create and render charts directly in your Robyn routes, and because pychartjs is framework-agnostic, it adapts well to any WSGI or ASGI framework.

Here’s how you can quickly set up a simple Robyn application with pychartjs:

from robyn import Robyn
from pychartjs.charts import Chart
from pychartjs.datasets import Dataset
from pychartjs.enums import ChartType
from robyn.templating import JinjaTemplate

app = Robyn(__file__)

template = JinjaTemplate("templates")

@app.get("/")
async def get_chart(request):
    dataset = Dataset(
        label="Sales Data",
        data=[10, 20, 30, 40, 50],
        backgroundColor="rgba(75, 192, 192, 0.2)",
        borderColor="rgba(75, 192, 192, 1)",
        borderWidth=1,
    )
    chart = Chart(
        chart_type=ChartType.LINE,
        datasets=[dataset],
        labels=["January", "February", "March", "April", "May"]
    )
    charts_html = chart.render()
    return template.render_template("index.html", charts_html=charts_html)

if __name__ == "__main__":
    app.start(port=8080)

Flexibility with HTML Rendering Options

One of the strengths of the updated pychartjs is its compatibility with a wide range of HTML rendering engines. Whether you're using Jinja in Flask, Django templates, or any other templating system, pychartjs fits seamlessly into your workflow. You can inject the rendered chart HTML into your templates, allowing for dynamic and interactive data visualizations in your web pages.

How to Get Started

Getting started with the new and improved pychartjs is straightforward:

1. Install pychartjs using Poetry:

    poetry add pychartjs
   

   Or, if you're using pip:

    pip install pychartjs
   

2. Integrate with Your Framework:

   Use pychartjs in your preferred Python web framework by creating and rendering charts directly in your views or routes.

   For example, in a Robyn app, you can render the charts directly into your HTML templates, as shown in the example above.

3. Customize Your Charts:

   With flexible rendering options, you can now tailor your charts to meet the specific needs of your application. Whether it’s context-aware rendering, custom styles, or integrating with dynamic data sources, pychartjs offers the flexibility to create exactly what you need.

Looking Ahead

This update is just the beginning. As pychartjs continues to evolve, I’m looking forward to seeing how the Python community will leverage its new capabilities. Whether you’re building data dashboards, integrating charts into web apps, or generating reports, pychartjs is here to make charting simple, flexible, and powerful.

Thank you to everyone who has supported pychartjs over the years. Your feedback and contributions have been invaluable in shaping this release. I’m excited to see what you all build with the new pychartjs.

Recently, I worked on a project that needed many gRPC functions. If you've used gRPC, you know it helps different software programs talk to each other efficiently. However, making Proto files for every Python dataclass was taking a lot of time and effort.

I needed to find a way to do this faster, so I built a Python library called Transmutate. This library helps create Proto files automatically from Python dataclasses. It also helps check if data is correct and makes working with gRPC easier.

The Problem with Proto Files

When using gRPC, we have to create Proto files. These files describe the data that the programs send to each other. Here are some problems I faced:

1. Writing Proto Files: Manually writing Proto files for each dataclass was boring and easy to make mistakes.

2. Keeping Things in Sync: When I changed the Python dataclass, I had to remember to update the Proto file, which sometimes I forgot to do.

3. Data Validation: I needed to make sure that the data followed certain rules, like checking if an email address was correct.

How Transmutate Solves These Problems

Transmutate automates a lot of these tasks. Here’s how it helps:

1. Automatic Proto Generation

With Transmutate, you don't have to write Proto files manually. The library generates them for you from your Python dataclasses.

Here's a simple example:

from transmutate.base_model import BaseModel
from typing import List

class Person(BaseModel):
    name: str
    age: int
    email: str
    phone_numbers: List[str]

# Generate Proto message
proto_definition = Person().to_proto()
print(proto_definition)

This will automatically create a Proto message like this:

message Person {
  string name = 1;
  int32 age = 2;
  string email = 3;
  repeated string phone_numbers = 4;
}

2. Built-In Field Validation

Transmutate allows you to add checks to make sure the data is valid. You can write functions that check each field. Here's an example:

class Person(BaseModel):
    name: str
    age: int
    email: str

    def validation_age(self):
        if not (0 <= self.age <= 120):
            raise ValueError("Age must be between 0 and 120.")

    def validation_email(self):
        if "@" not in self.email:
            raise ValueError("Invalid email address.")

In this example, the library will automatically run these checks when creating a Person object.

3. Easy gRPC Service Creation

Transmutate also helps create gRPC service definitions quickly. Here’s how you can define a service:

from transmutate import Service, RpcType

class TestService(Service):
    name = "TestService"
    types = [RpcType.UNARY]
    request_dataclass = Person
    response_dataclass = AnotherMessage

service_definition = TestService().generate_service_definition()
print(service_definition)

This generates a gRPC service definition without you having to write it manually.

Why Use Transmutate?

Here are some reasons why Transmutate is useful:

• Save Time: You spend less time writing Proto files and more time on real work.

• Reduce Errors: Automatic generation of Proto files reduces mistakes.

• Simple to Use: It works with existing Python code and is easy to add to your projects.

• Automatic Validation: Built-in checks ensure your data is correct.

Creating Transmutate helped me handle gRPC functions more easily. Instead of spending hours writing and managing Proto files, I can now focus on building features and solving problems.

You can find Transmutate on GitHub. Feel free to check it out, and if you find it helpful, please consider starring the repository or contributing to the project. Your feedback is welcome, and I hope this library makes your work with gRPC easier, just as it did for me.

Why Code Reviews Matter

Code reviews are a big deal in software development. They’re not just about finding bugs or making sure the code works. Here’s why they’re so awesome:

• Sharing Knowledge: When we review each other’s code, we learn new techniques and best practices. It’s like a mini-lesson every time.

• Improving Quality: More eyes on the code mean more chances to catch mistakes or think of better ways to do things.

• Keeping Things Consistent: It helps ensure everyone’s coding in the same style and following the same architecture, which makes the codebase cleaner and easier to maintain.

Appreciating Your Teammates

One of the best parts about code reviews is that it’s a chance to recognize the hard work of your teammates. Here’s how to do it right:

• Start with Positivity: Always kick off your feedback with what you liked about the code. It sets a good tone and makes your teammates feel valued.

• Be Constructive: When you point out issues or suggest changes, do it in a way that’s helpful and encouraging. Focus on how to improve, not just what’s wrong.

• Recognize Effort: Sometimes, the effort to solve a tough problem deserves a shout-out, even if the solution needs a bit more work.

Peer Programming and Its Benefits

Peer programming, also known as pair programming, is when two developers work together on one workstation. One writes the code while the other reviews each line as it’s written. This technique not only improves code quality but also enhances collaboration and learning.

• Real-Time Feedback: Issues can be identified and resolved immediately.

• Enhanced Learning: Both developers can learn from each other’s techniques and perspectives.

• Increased Engagement: Working together keeps both developers engaged and focused.

Discovering Git Add Co-Author

I recently found this neat tool on GitHub called Git Add Co-Author. It’s a game-changer for making sure everyone gets credit in commits. Here’s how you can use it:

1. Install It:

    pip install git-add-co-author
   

   Then configure it with your GitHub token:

    python -m git_add_co_author --token <your_token>
   

2. Add a Co-Author: To add a co-author, just run:

    python -m git_add_co_author --username <co_author_username>
   

   Or add their name and email directly (if you don't have GitHub token):

    python -m git_add_co_author --name "John Doe" --email "john.doe@example.com"
   

This way, the commit history shows everyone who contributed, which is awesome for open-source projects or pair programming sessions.

Wrapping Up

Code reviews are vital for learning, improving code quality, and keeping everything consistent. They’re also a great opportunity to show appreciation for your teammates’ hard work. Using tools like "Git Add Co-Author" makes it easy to give credit to everyone involved, enhancing team spirit and collaboration. If you want to dive deeper into appreciating contributions, check out my blog post.

I hope you are doing well. I want to share some important news with you. I am nominating myself for the position of Director on the Board of the Python Software Foundation (PSF).

My Statement

Here is my official statement for the PSF Board of Directors nomination:

I am honored to nominate myself for the position of Director on the Board of the Python Software Foundation (PSF). With extensive experience in Python development and a deep commitment to community engagement, I believe I can contribute significantly to the Foundation’s mission.

Background and Experience

I have been an active member of the Python community for over a decade, with experience ranging from standalone applications to backend systems and AI solutions. For the past few years, I have served as one of the managing committee members of TehPug, a 10-year-old community that participates in organizing PyCon in Iran. Our monthly meetings attract nearly 200 participants. Unfortunately, due to the situation in Iran, we do not have the same level of international activity or communication as communities in European countries. We aim to change this for the sake of knowledge and experience sharing. You can view my contributions on the Python Wiki.

My daily work involves using Python, and I have hosted numerous talks, meetups, and workshops aimed at empowering non-programmers, such as non-CS students, professionals in finance and accounting, and mechanical engineers, to use Python for automating repetitive tasks. These efforts not only expand the reach of Python but also equip individuals with valuable skills.

In addition to my technical contributions, I have actively worked to expand the Python community in regions with limited access to technology. I have led initiatives to introduce Python programming to underserved populations, providing them with the tools and knowledge to improve their career prospects. This includes organizing educational events and setting up community support systems in areas with poor internet access.

Statement of Concerns

My primary motivation for seeking a position on the PSF Board of Directors is to bring attention to the challenges faced by underrepresented and underserved communities within the Python ecosystem.

1. Access to Education: There are significant barriers to education for girls in Afghanistan. The denial of educational opportunities for these girls is a grave concern that needs to be addressed.

2. Internet Access: In countries like Iran, many people do not have reliable internet access due to both technical limitations and wide censorship, which severely limits their ability to learn and contribute to the Python community. The PSF can work with PyPI mirror providers to improve access in the MENA region, provide more offline shareable materials in local languages, and support local Python groups that may need OFAC licenses, making these accessible with the help of the PSF.

3. Support for Persian-speaking Communities: There is a notable absence of PyLadies chapters and Python support for Persian-speaking girls in Iran, Afghanistan, and other Persian-speaking countries.

4. Community Building in Arabic-speaking Countries: Even in relatively stable countries like Oman, there is a lack of a strong Python community, which I believe is partly due to cultural barriers.

Commitment to Advocacy

My candidacy is driven by a commitment to tell the stories of these underserved communities. It is not about whether I am elected or not; what is important is that the voices of these communities are heard. I want to highlight the impact that strong, inclusive communities can have in enabling individuals to find new opportunities and overcome societal barriers.

Conclusion

I am excited about the possibility of serving on the PSF Board of Directors and contributing to the Foundation’s efforts to create a more inclusive and supportive Python community. Thank you for considering my nomination.

OFAC License Application

I also want to share that I have applied for an OFAC license. This license will allow me to organize technology conferences, meetups, workshops, and other non-academic educational activities in countries with restrictions. However, I have not yet received an answer from OFAC.

Thank you for reading. Let's work together to make the Python community better for everyone.

Best regards

Recently, I decided to upgrade my system to Ubuntu 24.04. I enjoy keeping my setup current, and I wanted to take advantage of the latest features and improvements. Everything seemed to be going well until I hit a snag. I use virtualenvwrapper to manage my Python environments, but after the upgrade, it stopped working. I kept getting this error:

/usr/bin/python3: Error while finding module specification for 'virtualenvwrapper.hook_loader' (ModuleNotFoundError: No module named 'virtualenvwrapper')
virtualenvwrapper.sh: There was a problem running the initialization hooks.

If Python could not import the module virtualenvwrapper.hook_loader,
check that virtualenvwrapper has been installed for VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3 and that PATH is set properly.

Digging into the Problem

This was a new problem for me. I discovered that Python 3.12, which comes with Ubuntu 24.04, has stricter rules about installing packages globally. This change is designed to prevent conflicts and maintain system stability by keeping the system's Python environment clean. However, it also means you can't just use pip to install things globally like before. Instead, you have to use virtual environments for package management.

I initially tried using pipx to install virtualenvwrapper, but I ran into another issue. The virtualenvwrapper installed via pipx wasn’t accessible in my .zshrc configuration. It seems pipx is great for some standalone applications, but it doesn't play well with tools like virtualenvwrapper that need to be sourced in a shell configuration file.

Finding the Solution

To fix this, I decided to install virtualenvwrapper in its own virtual environment. Here’s how I did it:

Step 1: Create a Virtual Environment

First, I created a new virtual environment to keep things isolated.

python3 -m venv ~/.virtualenvs/venv

This command made a new virtual environment in the ~/.virtualenvs/venv directory.

Step 2: Activate the Virtual Environment

Next, I activated the virtual environment.

source ~/.virtualenvs/venv/bin/activate

The shell prompt changed, showing I was now working inside the venv environment.

Step 3: Install virtualenvwrapper

With the virtual environment activated, I installed virtualenvwrapper.

pip install virtualenvwrapper

Why Do This in a Virtual Environment?

1. Avoid Conflicts: Python 3.12 doesn’t let you install packages globally to avoid messing up the system’s packages. Using a virtual environment keeps everything separate.

2. Isolation: By installing in a virtual environment, virtualenvwrapper gets its own set of dependencies, with no interference from other projects.

3. Easy Management: If something breaks, you can just delete the virtual environment and start over, without affecting the system Python or other projects.

Step 4: Set Up My Shell

Next, I needed to tell my shell to use this new setup. I edited my .zshrc file (it could be .bashrc if you use bash).

Edit .zshrc

I opened my shell configuration file in a text editor:

nano ~/.zshrc

I added these lines:

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=$HOME/.virtualenvs/venv/bin/python
export VIRTUALENVWRAPPER_VIRTUALENV=$HOME/.virtualenvs/venv/bin/virtualenv
source $HOME/.virtualenvs/venv/bin/virtualenvwrapper.sh

What Do These Lines Do?

• export WORKON_HOME=$HOME/.virtualenvs: This sets the directory where virtualenvwrapper will keep all my virtual environments.

• export VIRTUALENVWRAPPER_PYTHON=$HOME/.virtualenvs/venv/bin/python: This tells virtualenvwrapper to use the Python from my virtual environment.

• export VIRTUALENVWRAPPER_VIRTUALENV=$HOME/.virtualenvs/venv/bin/virtualenv: This points to the virtualenv executable in my virtual environment.

• source $HOME/.virtualenvs/venv/bin/virtualenvwrapper.sh: This initializes virtualenvwrapper so I can use its commands.

Save and Exit

In nano, I saved the file by pressing Ctrl+O and then Enter, and exited with Ctrl+X.

Step 5: Reload My Shell Configuration

To apply the changes, I reloaded my shell configuration:

source ~/.zshrc

Step 6: Check the Installation

Finally, I checked to see if everything was set up correctly:

which mkvirtualenv

This command showed the path to the mkvirtualenv script in my virtual environment, confirming that everything was working.

Wrapping It Up

Upgrading to Ubuntu 24.04 brought a little challenge with virtualenvwrapper, but I learned a lot by solving it. By using a dedicated virtual environment, I kept my system clean and my projects organized. If you run into the same issue, I hope this guide helps you out. Happy coding!

I discovered Taiga, an open source project management tool, while browsing GitHub in 2019. As someone who enjoys open source, I’m always looking for ways to help out. I noticed that Taiga lacked a Persian translation. Although my main work involves coding, I saw this as a chance to contribute in a different way. I reached out to the Taiga team, offering to translate the project into Persian, and they welcomed my help.

The task of translating Taiga was challenging. I needed to understand the software well and ensure that the translations were accurate and clear. It wasn’t just about converting words from English to Persian; it was about making sure the translation was contextually appropriate and easy to understand for Persian-speaking users. I worked on translating the interface and documentation, though I didn’t complete the entire translation.

My translation work helped Persian-speaking users access and use Taiga more easily. I tried to make it easier for everyone who preferred to use software in Persian. It felt good to know that my effort could help others, even in a small way.

Seeing my name listed with other contributors like Amirhoshang Hoseinpour Dehkordi and Vahid Dayyani was heartwarming. It showed that contributions to open source come in many forms, not just coding. Translating, writing documentation, and other tasks are all important.

Working on Taiga taught me that open source projects need various skills. Writing, translating, designing, and testing are all crucial. Every contribution, big or small, helps make the project better and more accessible.

I want to encourage everyone to contribute to open source projects, even if you don’t write code. Open source is not just about programming; it's about creating a community where everyone’s skills are valued. Your skills, whether in translating, writing, designing, or testing, are valuable and can make a huge difference. Translating helps break down language barriers and makes the software accessible to more people. Writing documentation ensures that users and developers can understand and use the software effectively. Designing improves the user interface and experience, making the software more intuitive and user-friendly. Testing helps find and fix bugs, ensuring that the software works well for everyone.

Open source projects thrive on the diversity of contributions from many different people. Each contribution, no matter how small, helps to build and improve the project. By contributing your unique skills, you help create a richer, more inclusive community. Your efforts can inspire others to join in and contribute their skills as well. So, don’t hesitate to get involved. Your contributions are needed and appreciated. Together, we can make a significant impact and create something truly amazing.

Reflecting on my work with Taiga, I feel proud to be part of a community that values all kinds of contributions. My experience shows that open source is about more than just coding. It’s about collaboration and making technology better for everyone.

So, if you’re interested in an open source project, don’t hesitate to contribute. Your skills and efforts are needed and appreciated. You can make a difference, just like I did.

Remember, in the world of open source, every contribution matters. Together, we can create amazing things.

The Problem

In our small tech team, we often used Docker images and containers to streamline our development process. However, each time we started a new project or needed to make some tweaks, it was a hassle. We spent a lot of time modifying Docker Compose files or running containers with specific settings. It felt like a never-ending cycle of repetitive tasks, and it was frustrating.

The Idea

One day, while working late on a project, I was stuck in a loop of updating Docker Compose files and rerunning containers. I thought, "There has to be a better way to do this." That’s when the light bulb went off. What if we could have a tool that made managing these environments as easy as snapping your fingers? A tool that could handle all these tweaks and configurations effortlessly. And that’s how the idea of DevDock was born – a tool to put these tasks right at our fingertips.

What is a Dev Container?

Think of a dev container as a magic box. You put all your tools, libraries, and dependencies in it, and it keeps them safe and sound. When you open the box, everything is ready to use. It’s like having a personal chef who knows exactly how you like your meals.

Why Use Dev Containers?

But why should we use dev containers? Let me tell you:

1. Consistency: No more “It works on my machine!” Everyone on the team has the same setup.

2. Portability: Move your project to any computer, and it will work the same.

3. Efficiency: Saves time and reduces frustration.

Storing Configurations

As we began using dev containers, another realization struck me: having dev containers wasn’t enough. We needed a way to save our ideal setups so that we could recreate them effortlessly. Imagine if you could take a snapshot of your perfectly organized kitchen and set it up exactly the same way anywhere you go. That’s what storing configurations does for dev containers. It keeps your settings, dependencies, and tools saved, ensuring you can set up your development environment quickly and consistently every time.

The Birth of DevDock

With this realization, I started working on DevDock. My goal was simple: make it easy to create, manage, and store configurations for development containers. Unlike some IDE-specific solutions like what Visual Studio Code offers, I wanted DevDock to be IDE-independent. This way, developers using any code editor or IDE could benefit from a smooth, consistent development environment. I spent days coding, testing, and fixing bugs. There were challenging moments, but I kept going, motivated by the thought of making life easier for my fellow developers.

Features of DevDock

1. Create Containers: Easily create containers with all the tools and dependencies you need.

2. Store Configurations: DevDock stores your configurations in a simple YAML file. This means you can recreate your environment anytime, anywhere.

3. Manage Volumes: Need to save data inside your container? No problem! DevDock helps you manage volumes too.

4. Support for Docker Compose: If you have a complex setup with multiple services, DevDock supports Docker Compose, making it easy to manage.

5. IDE Independence: Unlike VS Code’s built-in dev containers, DevDock works with any IDE or code editor.

Using DevDock

Using DevDock is super simple. Here’s how you can start your own journey with DevDock:

1. Install DevDock:

    pip install devdock
   

2. Create a Container from an Image:

    devdock mkdevcontainer --image python:3.9 --name my-python-container --volumes /host/path1:/container/path1,/host/path2:/container/path2
   

   Imagine you need a Python environment for a new project. With DevDock, you can create a container with Python 3.9 and map your local directories to the container effortlessly.

3. Run Services from a Docker Compose File:

    devdock mkdevcontainer -f docker-compose.yaml --name my-compose --volume-mappings web:/host/path1:/var/www,web:/host/path2:/var/log/nginx,redis:/host/redis1:/data,db:/host/db1:/var/lib/postgresql/data
   

   Suppose you have a web project that also needs Redis and a PostgreSQL database. Using DevDock, you can specify your Docker Compose file and add volume mappings for each service, making the setup process a breeze.

4. Activate a Configuration:

    devdock workon my-compose
   

   Once your environment is set up, you can activate it with a single command. DevDock will start all the services defined in your configuration, so you can get to work immediately.

5. Activate Specific Services:

    devdock workon my-compose --services web
   

   If you only need to work on the web service, DevDock can activate just that service along with its dependencies, saving you resources and startup time.

6. Run a Command Inside a Specific Service:

    devdock run my-compose --service web "echo Hello, World!"
   

   Need to run a command inside the web service? DevDock makes it simple. Just specify the service and the command, and DevDock takes care of the rest.

7. Enter Shell Inside a Specific Service:

    devdock shell my-compose --service web
   

   For more interactive work, you can enter a shell inside any service. This is great for debugging or making quick changes.

8. Remove a Configuration:

    devdock rmdev my-compose
   

   When you're done with a project, you can clean up easily. DevDock removes all the containers and configurations associated with your project, keeping your system tidy.

Join the Adventure

Creating DevDock has been an incredible journey. It started with a simple idea and grew into a tool that can help developers everywhere. Now, with DevDock, you can manage your dev containers with ease, save your configurations, and never worry about setting up your environment again.

If you’re a developer looking for a smoother workflow, give DevDock a try. I promise, it will make your coding life a lot easier. And who knows, you might just fall in love with it as much as I did.

I would love your feedback and contributions. If you have any ideas, suggestions, or find any issues, please visit our GitHub repository. Your contributions will help make DevDock even better.

GitHub Repository: DevDock GitHub Repository

If you have any questions or need help, feel free to reach out. I’m always happy to help fellow developers.

Reproducing the Bug

To solve the issue, we first needed to reproduce the bug. Here are the steps we took:

1. Install Hazm on Python 3.12: We started by trying to install Hazm in a Python 3.12 environment using the following command:

    pip install hazm
   

   Identify the Compatibility Issue: During installation, we encountered an error related to the deprecated triu function from SciPy, which Gensim used. The error message pointed us directly to the problem with the triu function.

2. Investigate Dependencies: We examined Hazm's dependencies and found that it relied on Gensim. To confirm that Gensim was the source of the problem, we tried installing Gensim separately and encountered the same error.

Review Gensim's Repository: Determined to find a solution, we checked the Gensim GitHub repository. We noticed that the development branch was 25 commits ahead of the latest release tag. The latest release had an issue with the deprecated triu function from SciPy, which Gensim used. Fortunately, we found that this problem was fixed in a commit on the development branch.

Our Approach to Solving the Issue

To address this issue, we used Poetry, a tool for dependency management and packaging in Python. Poetry allows installation from a specific commit, which was crucial because we needed the latest changes from the development branch of Gensim, not the stable release.

Steps We Took:

1. Use Poetry for Installation: We used Poetry to install Gensim from the specific commit where the issue was resolved. We add the package manually in pyproject.toml:

    gensim={git = "https://github.com/piskvorky/gensim.git", rev ="commit-hash"}
   

   Replace <commit-hash> with the actual commit hash where the issue was fixed.

2. Test the Solution: We tested the new setup, and it worked perfectly with Python 3.12.

3. Contribute Back: We made a pull request to the Hazm repository to share our solution with the community. You can see our commits here: Hazm Pull Request #338.

Temporary Solution for Hazm Users

Until our pull request is merged into the main Hazm repository and published on PyPI, users can use the same approach we used for Gensim. This means installing Hazm from Mahdi's repository using either pip or Poetry.

Installing Hazm from Mahdi's Repository

You can follow these steps to install Hazm from the specific branch that includes our fix.

Using pip

1. Open your terminal or command prompt.

2. Run the following command:

    pip install git+https://github.com/mahdisharifloo/hazm.git@master
   

This command tells pip to install Hazm directly from Mahdi's GitHub repository from the master branch.

Using Poetry

1. Open your terminal or command prompt.

2. Navigate to your project directory.

3. Add the Hazm package from Mahdi's repository with the following command:

    poetry add git+https://github.com/mahdisharifloo/hazm.git
   

This command instructs Poetry to add Hazm to your project's dependencies, pulling it directly from the specified repository and branch.

Conclusion

By following these steps, we were able to fix the compatibility issue with Hazm and Python 3.12. We hope our solution will help others facing the same problem.

Our experience has taught us the importance of being proactive and contributing back to the open-source community. By sharing our solution, we aim to help others who might encounter similar issues.

Until our changes are merged into the official Hazm repository and a new version is released on PyPI, users can follow our example to use the fixed version of Hazm from Mahdi's repository.

We look forward to seeing our contribution help improve Hazm for everyone in the community.

For more details, you can see the comparison and commits related to our fix here: Comparison and Commits.

We hope this guide helps you navigate similar issues and contributes to smoother development experiences.

I was casually exploring GitHub when I stumbled upon PGMQ, a project using PostgreSQL for message queuing. I found a typo in the README and thought, "Why not fix it?" So, I forked the repo, corrected the typo, and submitted my first pull request. To my surprise, it got merged! Feeling like a hero, I decided to dive deeper.

Encouraged by my first success, I explored the codebase more. I noticed PGMQueue lacked support for environment variables. Thinking it was a simple task, I added the python-dotenv library and submitted another pull request (PR #222). Then came the feedback. One collaborator wasn't a fan of auto-loading environment files and suggested reading environment variables directly. Another contributor liked the idea but recommended avoiding the dependency on python-dotenv.

After much discussion and feedback, I removed python-dotenv and changed the implementation to use environment variables if provided. Additionally, we decided to use unittest instead of pytest for consistency. I rewrote all the tests, learning a lot along the way.

In another instance, I updated the development dependencies in the pyproject.toml file, only to receive feedback that I had removed some necessary ones. After some tweaks and running poetry lock --no-update, everything was sorted out.

We also revised the README to avoid using python-dotenv, making the setup simpler and cleaner. Despite the challenges, these experiences were full of insights and learning opportunities.

Feeling more confident, I tackled more significant features. One ongoing project is adding support for metrics to the Python library (PR #227). This should help users gain better insights into their queue operations.

Looking back, it's funny how a small typo led me to contribute to a project I really enjoy. Each task, no matter how simple, taught me something valuable. If you're thinking about contributing to open source, just go for it! Every little step counts.

For more details, check out my contributions: PR #214, PR #222, and PR #227.

At work, I dive into Django projects all the time. Recently, I found out that Typer and Jinja2 are total game-changers. These tools help me whip up serializers, views, and routes super fast. During the talk, I showed how these simple functions can handle all the boring, repetitive tasks, leaving us with more time for the fun and challenging parts of coding.

I kicked off the talk by showcasing my little libraries on PyPI. I explained how each step in contributing to the community counts and encouraged everyone to publish their code, no matter how small it might seem. Sharing my journey from being a new contributor a few years ago to now was an important part of the talk. I wanted to show that anyone can be part of this amazing community with persistence and passion.

Then, I dove into the core of my presentation: my code generator. I explained how this tool, built with Typer and Jinja2, automates the creation of Django serializers, views, and routes. By leveraging these libraries, the generator streamlines the development process, allowing us to focus on more complex tasks.

The best part was seeing everyone’s excitement and curiosity. It was great to answer your questions and see how these tools can be applied to your projects. I hope you all walked away with some fresh ideas and inspiration.

Despite the unexpected nature of the talk and my broken hand, it was a fantastic experience. Your enthusiasm and support made it all worth it. I can't wait for the next meetup to share more tips and tricks. Until then, keep coding and having fun!

Clean Architecture is a respected design pattern used by many seasoned developers to organize complex projects into clear, distinct layers. Each layer serves a specific function, which can greatly enhance project structure and maintainability in certain contexts. However, it also introduces complexity that may not always be necessary, especially in more straightforward applications.

In contrast, Django, a popular Python framework for building websites, champions a simpler, more integrated approach guided by the "Zen of Python" — a set of principles formulated by Tim Peters that emphasize readability and simplicity. One key tenet from this set, "Simple is better than complex," aligns closely with Django's philosophy.

Throughout this post, we'll explore scenarios where Django's straightforward methodology provides all the functionality needed without the additional layers proposed by Clean Architecture. While Clean Architecture has its merits, particularly in complex systems, Django's design is intended to streamline development and make the process more accessible and efficient. We will delve into how Django’s built-in tools often suffice for many web projects, making it a practical choice for developers who value simplicity and speed. Let’s explore the strengths of keeping things simple with Django.

1. Contrasting Philosophies

let's look at how the ideas behind Clean Architecture clash with the simple and clear principles of the "Zen of Python."

Complexity vs. Simplicity

The "Zen of Python" tells us that "Simple is better than complex." This means that when we write our code, it's better to keep it easy to understand and manage. However, Clean Architecture does the opposite by breaking the project into many different layers. Each layer has its role, which might sound organized, but it actually makes things more complex than necessary. For example, in a Django project, we could usually write a feature with fewer steps and less confusion if we skip the extra layers that Clean Architecture suggests.

Explicit vs. Implicit

Another important idea from the "Zen of Python" is "Explicit is better than implicit." This means our code should clearly show what it does. Clean Architecture, with its many layers, often hides the details of how things work. This can make it hard to understand the code because you can't see directly what it is doing. In Django, it's usually better to have code that shows clearly and directly what happens, which helps anyone who reads or works with it.

By comparing these philosophies, we can see that Django's straightforward approach often makes more sense than adding the complexity of Clean Architecture. Keeping things simple and clear helps us maintain and develop projects more effectively.

2. The Pythonic Way: Embracing Django’s Strengths

In this part, we'll focus on how Django's features support a simpler and more straightforward way of coding, which is very much in line with Python's principles.

ORM and Model Managers

One of Python's key ideas is "Flat is better than nested." This means that having a simple, one-level structure is better than a complicated multi-level setup. Django’s Object-Relational Mapping (ORM) system follows this idea very well. It allows us to work with database information easily and clearly, without needing to set up many layers of code. Clean Architecture, on the other hand, often involves creating several nested layers to handle data, which can make the process slower and harder to manage. By keeping the structure flat, Django makes it much easier for us to see and control what our code does.

Built-in Functionalities

Another Python principle says, "If the implementation is easy to explain, it may be a good idea." Django lives up to this by providing built-in tools that are simple to use and explain. For example, Django's admin site lets us manage data in our database visually and straightforwardly, without complex setup. Similarly, Django's middleware and authentication systems are designed to be easy to add and understand. These features show how Django keeps things practical and user-friendly, avoiding unnecessary complications that could make the work harder.

By using Django's strengths, we can keep our projects clear and manageable, respecting Python's guidelines for simplicity and clarity. This approach not only makes our code better but also makes our life as developers easier.

3. The Burden of Overengineering

Overengineering means making a project more complicated than it needs to be, which can lead to several problems. Let’s look at how using Clean Architecture in Django projects can create extra challenges.

Setup and Maintenance Challenges

The "Zen of Python" tells us, "Complex is better than complicated." This means we should aim for solutions that might be a bit sophisticated but still straightforward rather than solutions that are just unnecessarily confusing. Setting up Clean Architecture in Django often leads to this unnecessary confusion. It requires us to create many separate layers and components, which can be hard to set up and keep running smoothly. This setup doesn’t just make the initial development slower but also makes future changes and maintenance harder because there are more pieces to update and more potential for mistakes.

Performance and Scalability Issues

Python’s philosophy also includes "In the face of ambiguity, refuse the temptation to guess." This is about avoiding uncertain situations where you might not know the best course of action. Clean Architecture, with its multiple abstraction layers, can introduce uncertainty about where performance issues might occur. Because the system is divided into many layers, it’s not always clear which layer is causing a slowdown or problem, making it hard to optimize and scale the system efficiently. This guessing game can lead to poor performance and scalability, which are critical aspects of any web application.

By avoiding overcomplicated designs like those often seen with Clean Architecture, we can keep our Django projects more manageable, performant, and scalable. Keeping things simpler helps us maintain clarity, which is crucial for successful development and operation.

4. Practical Implications and Developer Experience

Let’s talk about how Clean Architecture influences the day-to-day work of developers and adds complexity to coding tasks.

Development Friction and Onboarding

One important idea from the "Zen of Python" is "Readability counts." This means code should be easy to read and understand. Clean Architecture can make code more complicated, which is tough for new developers. When the code is hard to follow, it takes more time for newcomers to figure out where things are and how they work. This can slow down their ability to contribute and extend the time needed to get projects done.

Overloaded Views and Serialization

"Sparse is better than dense" is another guideline from Python. It suggests that code should not be too packed with information. This keeps it easy to read and manage. However, in Django projects using Clean Architecture, views and serializers tend to have too much going on. They handle too many tasks and contain too much information, which makes the code hard to work through. This can lead to mistakes and make it challenging for developers to update or improve the code.

By making our Django projects simpler and more organized, we make sure that the code is user-friendly and easy to handle. This not only makes work faster but also leads to better software overall.

5. When Django’s Simplicity Triumphs

Let’s explore why Django’s straightforward approach is often the best choice for many projects.

Real-World Use Cases

The "Zen of Python" has a principle: "Special cases aren't special enough to break the rules." This means that we should not change our usual methods just because something might seem like a unique situation. In many real-world projects, Django’s standard setup is more than enough. Most of the time, the extra layers and complexity of Clean Architecture are not needed. Django’s simpler approach fits well with many types of projects, making it unnecessary to complicate things with a specialized structure like Clean Architecture.

Simplicity as a Strategic Advantage

Another Python guideline is "Although practicality beats purity." This suggests that what works in real situations is more important than perfect theories. Django’s built-in tools and straightforward structures work very well and are easy to use. They help us get things done efficiently and effectively. Choosing these simple, practical solutions over the complicated and often theoretical approach of Clean Architecture can be a strategic advantage. It helps keep projects manageable and reduces the risk of problems caused by unnecessary complexity.

By sticking to Django’s simple and direct methods, we can handle most project needs effectively. This approach not only saves time but also keeps our projects strong and flexible.

Conclusion

In conclusion, this discussion highlights that Django's inherent simplicity and its alignment with Python's core philosophies often make it the superior choice for web development projects. By adhering to principles like "Simple is better than complex" and "Readability counts," Django not only fosters a more straightforward development process but also enhances maintainability and scalability.

As developers, we face numerous decisions that impact the practical outcomes of our projects. Embracing Django’s built-in functionalities and straightforward architecture can help us avoid the pitfalls of overengineering. This simplicity is not just about ease of use—it’s about making our software robust and accessible, especially for those who will maintain and evolve our codebases in the future.

I encourage everyone to share your thoughts and experiences on using Django and Clean Architecture. Have you found that Django’s simpler approach benefits your projects? Or have there been instances where a more complex architecture like Clean Architecture was necessary? Your insights can help others in the community weigh the practical benefits of simplicity against the demands of architectural complexity in their own projects. Let’s discuss and learn from each other’s experiences to find the best paths forward in our development practices.

That's where the idea for ezkernel (short for "easykernel") came from. As someone who frequently toggles between different Jupyter kernels, I wanted a simpler, more straightforward way to manage them—something that didn't disrupt the flow of my work. ezkernel is designed to be that friendly tool in your toolkit, making kernel management as easy as a few simple commands.

The Genesis of ezkernel

The journey to ezkernel began with a common frustration: the constant need to look up commands or navigate through Jupyter's interface just to manage kernels. Whether it was adding a kernel for a new project, cleaning up old kernels, or renaming kernels for clarity, each task seemed to require more steps than necessary.

ezkernel aims to streamline these tasks, embodying the principle that tooling should make our lives easier, not more complicated. It's built for those moments when you think, "There has to be an easier way to do this."

Core Features of ezkernel

ezkernel focuses on three key functionalities, all accessible through an intuitive command-line interface:

• Add Kernels Quickly: Add new kernels with a single command, specifying just the name and an optional display name.

• Remove Kernels Easily: Clean up your workspace by removing unnecessary kernels without hassle.

• Rename Kernels for Clarity: Update kernel names to reflect their current use or environment, helping you stay organized.

Getting Started

Getting up and running with ezkernel is straightforward. Install it via pip with:

 pip install ezkernel

Adding a Kernel

To add a new kernel, simply use:

ezkernel add my_kernel --display-name "My Kernel"

Removing a Kernel

To remove a kernel, the command is just as simple:

ezkernel remove my_kernel

Renaming a Kernel

And renaming a kernel is equally straightforward:

ezkernel rename old_name new_name

The Philosophy Behind ezkernel

ezkernel was born out of a desire to reduce friction and make the daily tasks of developers and data scientists a bit more pleasant. It's a testament to the idea that sometimes, small tools can make a big difference in our workflow and productivity. By focusing on ease of use and simplicity, ezkernel invites more people to work efficiently with Jupyter, regardless of their level of expertise.

In Conclusion

If you've ever found yourself interrupted by the need to manage Jupyter kernels, ezkernel is for you. It's a small tool with a simple mission: to make kernel management effortless, letting you focus on the more important and exciting aspects of your work.

Try ezkernel today, and experience a smoother, more intuitive way to manage your Jupyter kernels. Here's to making our work with Jupyter notebooks just a little bit easier!

I'm excited to share a project that's been my companion during many late nights and early mornings: "A Comprehensive Guide to Git & GitFlow." This isn't just a book; it's a reflection of my journey with Git, the challenges, the triumphs, and everything in between.

Why This Book?
Every challenge I faced, every "Eureka!" moment I had with Git, I jotted down. I wanted to share those insights, hoping they might make someone else's journey a bit smoother.

What's Inside?
From the basics for those just starting, to the deeper dives for the seasoned coders, it's all in there. It's my Git journey, and I hope it helps guide yours.

Check It Out on GitBook:
I chose GitBook for its simplicity. Dive in here.

Your Thoughts?
I'd love to hear your feedback, thoughts, or any Git stories you'd like to share.

Thanks for being a part of this journey with me. Happy coding!

1. The Inflection Point: As we approach the singularity, technology doesn't just progress; it bends, twists, and reshapes at an unprecedented pace. "Techbend" captures that exhilarating moment when technological advancements are no longer linear but exponential, opening doors to possibilities beyond our wildest imaginations.

2. Harmonizing Entities: In this era, humans and machines are not distinct but intertwined. "Techbend" symbolizes this seamless fusion, where technology bends to complement human potential, leading to a unified, enhanced existence.

At the heart of it, "Techbend" is a testament to the transformative power of technology in an age where boundaries blur, and the unimaginable becomes reality.