<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Cristian on Medium]]></title>
        <description><![CDATA[Stories by Cristian on Medium]]></description>
        <link>https://medium.com/@leviathan36?source=rss-9986e6a57d4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Wd6FBAIorMMA7xYTuNxtfw.png</url>
            <title>Stories by Cristian on Medium</title>
            <link>https://medium.com/@leviathan36?source=rss-9986e6a57d4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 11:23:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@leviathan36/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Type Checking in Python ✅]]></title>
            <link>https://medium.com/@leviathan36/type-checking-in-python-a874e34d7624?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/a874e34d7624</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Sun, 19 Oct 2025 11:41:55 GMT</pubDate>
            <atom:updated>2025-10-19T11:41:55.154Z</atom:updated>
            <content:encoded><![CDATA[<h3>Type Checking in Python</h3><h4>It’s so simple and so underrated</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yvpBJP5N_9WxATu5T9I6BA.jpeg" /><figcaption>Prohibitory road sign by <a href="https://www.pexels.com/it-it/@cigdem-bilgin-2154409770/">cigdem-bilgin-2154409770</a></figcaption></figure><h3>Dynamic Type Checking</h3><p>Python is a dynamically typed language, meaning that type checking of variables occurs at runtime during code interpretation. However, what often happens is that the Python interpreter performs implicit conversions at runtime, or, simply because we don’t necessarily have to specify the types of the objects we use, we might pass an object of the wrong type to a function. These situations, obviously, lead the code to generate errors.</p><p>In the best-case scenario, the program crashes and throws an exception, thus avoiding the production of incorrect and unexpected results. In the worst-case scenario, however, the latter situation occurs: the code terminates correctly (returns 0), but the results produced are completely inaccurate, making it difficult to notice and debug the code.</p><p>These type-related errors happen because Python doesn’t require specifying the type of function parameters. This makes it easier for a programmer to mistakenly call a function with parameters of the wrong type. Or, even if we do specify the parameter types, Python doesn’t have a default type enforcement mechanism and doesn’t check if the function is actually called with the correct parameters. Type hints are merely an indication for the programmer, helping with documentation.</p><p>However, thanks to external packages, we can implement dynamic type checking by leveraging the type hints in the function signature.</p><p>To do this, we can use beartype ( <a href="https://github.com/beartype/beartype">https://github.com/beartype/beartype</a>).</p><h3>Installation</h3><pre>pip install beartype</pre><h3>Basic Usage</h3><pre>from beartype import beartype # decorator to add to functions and classes<br>from beartype.typing import * # imports all beartype types, overwriting classes from the standard typing package<br><br>@beartype<br>def foo(a: int, b: str) -&gt; bool:<br> a += 1<br> print(b + str(a))<br> return True</pre><p>This function, in its simplicity, could cause the code to crash if called with two string parameters or two integer parameters. The “beartype” decorator, in this case, doesn’t help prevent this type of error directly but rather provides a clearer error message and stops the function’s execution right at the start-as soon as it’s invoked with parameters of the wrong type. This prevents any strange and potentially dangerous behavior (think about functions that save to databases).</p><p>In some cases, however, the function might execute and terminate with code 0 even if the input parameters are incorrect. In this situation, using beartype is the only way to prevent the code from executing incorrectly and unpredictably:</p><pre>from beartype import beartype # decorator to add to functions and classes<br>from beartype.typing import * # imports all beartype types, overwriting classes from the standard typing package<br><br>@beartype<br>def foo(a: int, b: int) -&gt; None:<br> c = a + b<br> print(c)<br> # save &quot;c&quot; into db</pre><p>The function above would terminate correctly whether it’s passed two integers or two strings. The only way to prevent this is by using beartype.</p><p>This package does what could be done more simply with 30 lines of code in a “handmade” decorator; however, the package guarantees a signature analysis time with constant computational complexity, which is truly remarkable!</p><h3>“Static” Type Checking</h3><p>The best approach, however, would be to also check types statically, before executing the code. Python doesn’t provide any mechanism for this, but we can use third-party tools that allow us to achieve a similar result. For example, we can use a linter, such as Pylint. When installed within your IDE, it can check if the function signatures are consistent with their usage (this obviously requires inserting types in the function signatures).</p><p>It’s also possible to use Pylint as a standalone command; you just need to install it with pip:</p><pre>pip install pylint</pre><p>Another excellent linter is Flake8. You can also use this linter within your IDE (most popular code editors have ready-to-use extensions in their marketplace).</p><p>Theoretically, you could use both to validate your code, aiming to highlight as many errors as possible before sending it to production.</p><p>To install it, again, just run:</p><pre>pip install flake8</pre><p><em>Originally published at </em><a href="https://leviathan36.github.io/yase/rest_api_101/1">https://leviathan36.github.io/yase/rest_api_101/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a874e34d7624" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Authentication in FastAPI ]]></title>
            <link>https://medium.com/@leviathan36/authentication-in-fastapi-57cd858031c2?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/57cd858031c2</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[fastapi]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Wed, 15 Oct 2025 19:11:46 GMT</pubDate>
            <atom:updated>2025-10-15T19:11:46.764Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Authentication in FastAPI is the process of verifying a user’s identity before granting them access to protected API endpoints. It typically involves using a security scheme, like OAuth2 with bearer tokens, to handle user credentials securely.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UA5nmJ4cEcehPJIGgKyKKA.jpeg" /><figcaption>Lock by <a href="https://www.pexels.com/it-it/@life-of-pix/">life-of-pix</a></figcaption></figure><p>Of course, FastAPI also implements several plug-and-play authentication methods. Then, if we want to write our own authentication function, obviously, we can do that, but it’s highly discouraged for obvious reasons.</p><p><a href="https://fastapi.tiangolo.com/tutorial/security/oauth2-jwt/#advanced-usage-with-scopes">OAuth2 with Password (and hashing), Bearer with JWT tokens — FastAPI</a></p><p>Let’s look at the minimum necessary steps to implement JWT-based authentication.</p><p>First of all, what is JWT?</p><blockquote><em>JWT (JSON Web Token) based authentication is a stateless method where, after login, the server issues a digitally signed token containing information (claims) about the user. The client sends this token with each subsequent request in the </em><em>Authorization header. The server verifies the token&#39;s signature and validity (e.g., expiration) to authenticate the user without needing to consult a session state on the server.</em></blockquote><p>So, we would need these 2 functions at a minimum:</p><ul><li><strong>create_access_token</strong>: to create the encrypted token with the user information passed as input. This token, as mentioned above, will be used by the server to verify that the user is authenticated and authorized to perform operations. Indeed, since the token is encrypted, it can only be forged by the server, and any attempt at tampering will invalidate the token. In essence, if the server receives a valid token, by decrypting it, it will be able to find the information of the user to whom this token is associated and verify if they can indeed perform the requested operation. Obviously, if this token is stolen, the user who obtains it can impersonate the user from whom it was stolen, and the server will not be able to detect this, allowing them to perform operations that the legitimate user (from whom the token was stolen) has access to.</li><li><strong>get_current_user</strong>: this function, unlike the previous one, decrypts the token, retrieving the user information contained within it.</li></ul><p>Let’s see how to implement them:</p><pre>import jwt<br>from datetime import datetime, timedelta<br><br># The key should be created with this command:<br># openssl genrsa -out ./private.key 4096<br># This one is just an example to keep the code simple<br>SECRET_KEY = &quot;your-secret-key&quot;<br>ALGORITHM = &quot;HS256&quot;<br><br>def create_access_token(data: dict, expires_delta: timedelta = None):<br>    to_encode = data.copy()<br>    if expires_delta:<br>        expire = datetime.utcnow() + expires_delta<br>    else:<br>        expire = datetime.utcnow() + timedelta(minutes=12000) # Default to a long expiration if not provided<br>    to_encode.update({&quot;exp&quot;: expire})<br>    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)<br>    return encoded_jwt</pre><pre>from fastapi import Depends, HTTPException<br>from fastapi.security import OAuth2PasswordBearer<br>import jwt<br><br>SECRET_KEY = &quot;your-secret-key&quot; # Must be the same as defined above<br>ALGORITHM = &quot;HS256&quot; # Must be the same as defined above<br><br>oauth2_scheme = OAuth2PasswordBearer(tokenUrl=&quot;login&quot;) # tokenUrl points to your login endpoint<br><br>def get_current_user(token: str = Depends(oauth2_scheme)) -&gt; str: # Changed Depends to use the oauth2_scheme instance<br>    try:<br>        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])<br>        username: str = payload.get(&quot;sub&quot;) # It&#39;s good practice to add type hints<br>        if username is None:<br>            raise HTTPException(status_code=400, detail=&quot;Invalid token: username missing&quot;) # More specific error<br>        # token_data = username # This line isn&#39;t strictly necessary if you just return username<br>    except jwt.ExpiredSignatureError:<br>        raise HTTPException(status_code=401, detail=&quot;Token has expired&quot;)<br>    except jwt.JWTError: # Catch any other JWT related errors<br>        raise HTTPException(status_code=401, detail=&quot;Invalid token&quot;)<br>    return username # Return the username directly</pre><p>Finally, let’s put everything together and create the route to handle authentication:</p><pre>from fastapi import APIRouter, Depends, HTTPException<br>from fastapi.security import OAuth2PasswordRequestForm<br>from passlib.context import CryptContext<br>from datetime import timedelta<br><br>import sqlmodel as sm # Assuming you&#39;re using SQLModel<br>from sqlmodel import Session # For type hinting<br><br>from app.db.session import get_session # see sqlmodel/fastapi project section<br>from app.datamodel.user import User # Assuming User is your SQLModel user model<br><br>ACCESS_TOKEN_EXPIRE_MINUTES = 30<br><br>auth_router = APIRouter() # Renamed to auth_router for clarity, standard practice<br><br>pwd_context = CryptContext(schemes=[&quot;bcrypt&quot;], deprecated=&quot;auto&quot;)<br><br>@auth_router.post(&quot;/login&quot;) # Changed to use auth_router<br>async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_session)):<br>    # It&#39;s generally better to query by a unique username or email<br>    # Assuming form_data.username is the unique identifier for the user (e.g., email or username field)<br>    user_query = sm.select(User).where(User.id == form_data.username) # Assuming User.id is the username field<br>    user_in_db = db.exec(user_query).first() # .first() is often more appropriate for unique lookups<br><br>    if not user_in_db:<br>        raise HTTPException(<br>            status_code=400,<br>            detail=&quot;Incorrect username or password&quot;, # Generic message for security<br>        )<br>    <br>    # Assuming your User model has a &#39;password_hash&#39; field<br>    if not pwd_context.verify(form_data.password, user_in_db.password_hash):<br>        raise HTTPException(<br>            status_code=400,<br>            detail=&quot;Incorrect username or password&quot;, # Generic message for security<br>        )<br><br>    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)<br>    access_token = create_access_token(<br>        data={&quot;sub&quot;: user_in_db.id}, expires_delta=access_token_expires # Use the actual user ID or unique identifier from DB<br>    )<br>    return {&quot;access_token&quot;: access_token, &quot;token_type&quot;: &quot;bearer&quot;}</pre><p>For completeness, here’s the DB interaction part again:</p><pre># pip install sqlmodel<br>from sqlmodel import create_engine, Session, SQLModel # Added SQLModel import<br><br>DATABASE_URL = &quot;sqlite:///./test.db&quot;  # You can also use other databases (PostgreSQL, MySQL, etc.)<br>engine = create_engine(DATABASE_URL, echo=True)<br><br>def create_db_and_tables():<br>    SQLModel.metadata.create_all(engine) # SQLModel should be imported<br><br>def get_session():<br>    with Session(engine) as session:<br>        yield session</pre><p>Now, all that’s left is to see how to make an API “authenticated.” The step is very simple and doesn’t require rewriting the API. This means that if you want, you can transform a non-authenticated API into an authenticated one very easily and quickly:</p><pre>import sqlmodel as sm # Assuming you are using SQLModel, &#39;sa&#39; usually refers to SQLAlchemy core<br>from typing import Any # For type hinting<br><br>from app.db.session import get_session<br>from app.datamodel.order import Order # Assuming Order is your SQLModel order model<br>**from app.auth import get_current_user** # Assuming your auth functions are in app.auth<br><br># Assuming &#39;app&#39; is your FastAPI instance or an APIRouter<br># from fastapi import APIRouter<br># app = APIRouter() # Or your FastAPI app instance<br><br>@app.get(&quot;/order&quot;, response_model=Order) # Ensure &#39;app&#39; is defined (FastAPI instance or APIRouter)<br>async def get_order_detail(<br>    id: int,<br>    **current_user_id: str = Depends(get_current_user)**, # Renamed for clarity that it&#39;s the user_id from token<br>    db: Session = Depends(get_session)<br>) -&gt; Any: # Or more specifically -&gt; Order<br>    # Assuming Order model has a user_id field to associate orders with users<br>    query_select_order_by_id = sm.select(Order).where(sm.and_(Order.id == id, Order.user_id == current_user_id))<br>    order = db.exec(query_select_order_by_id).first()  # &#39;order&#39; is a more conventional name for the result<br><br>    if order:<br>        return order<br>    else:<br>        # It&#39;s good practice to use FastAPI&#39;s HTTPException here<br>        raise HTTPException(status_code=404, detail=f&quot;No order found with id: {id} for the current user.&quot;)<br>        # raise_error(404, f&quot;No asset found with id: {id}.&quot;) # Assuming raise_error is a custom function</pre><p>If the JWT token is not valid, the get_current_user function itself will raise an exception. The user&#39;s privilege check, i.e., which orders they can actually access, is instead done directly through the query in the code.</p><p><em>Originally published at </em><a href="https://leviathan36.github.io/yase/rest_api_101/">https://leviathan36.github.io/yase/rest_api_101/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=57cd858031c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAPI Pagination ]]></title>
            <link>https://medium.com/@leviathan36/fastapi-pagination-c6831fd34d2b?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/c6831fd34d2b</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[fastapi]]></category>
            <category><![CDATA[pagination]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Tue, 07 Oct 2025 18:28:07 GMT</pubDate>
            <atom:updated>2025-10-07T18:28:07.027Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Pagination on websites is the process of dividing a large amount of content into separate, numbered pages. This improves user experience by making the content easier to navigate and helps pages load faster.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5eMLi1gf9eSnG-TyX3Sqjg.jpeg" /><figcaption>book by <a href="https://www.pexels.com/it-it/@pixabay/">pixabay</a></figcaption></figure><p><strong>Pagination</strong> in APIs is an essential technique used when an endpoint might return a large number of results (for example, a list of products, users, or posts). Instead of sending all the data in a single, potentially huge and slow response, the API divides the complete result set into smaller, more manageable “pages.”</p><p>The client can then request these pages one at a time, typically by specifying parameters like the desired page number and the page size (how many items per page). This approach significantly improves performance, reduces the load on both the server and the client, and makes data transfer over the network more efficient.</p><p>It can be implemented manually, quite simply, by adding two additional parameters to each API:</p><ul><li>page</li><li>size</li></ul><p><em>For more granular control over the results, you can use the keywords </em><em>offset and </em><em>limit. These can, hypothetically, return a batch of records starting from any position (offset).</em></p><p>These two parameters (whose names are standard) will then be used to construct the database query like this:</p><pre>SELECT * FROM people ORDER BY first_name, id LIMIT &lt;size&gt; OFFSET &lt;page*size&gt;</pre><p>Obviously, there are also faster, “pre-packaged” methods for implementing pagination, especially if you’re using FastAPI. Specifically, let’s look at the fastapi-pagination package ( <a href="https://github.com/uriyyo/fastapi-pagination">https://github.com/uriyyo/fastapi-pagination</a>).</p><p>This package allows you to wrap your entire application ( app) so that all routes implicitly implement pagination without needing to modify their function signatures; in fact, the size and page parameters are added by the package itself. This feature can be very useful if you want to add pagination to an existing application.</p><p>Then, you just need to add the final line where you call the paginate function, which automatically handles the pagination:</p><pre>return paginate(db, select(User).order_by(User.created_at))</pre><p>ATTENTION: The paginate function depends on the type of DB/ORM being used, so make sure to import the correct function based on the database you are using. For example, for SQLAlchemy, you need to import:</p><pre>from fastapi_pagination.ext.sqlalchemy import paginate</pre><p>Let’s quickly see how to use this package:</p><ul><li>Installation:</li></ul><pre>pip install fastapi-pagination</pre><ul><li>Wrapping the app:</li></ul><pre>from fastapi import FastAPI<br><br># import all you need from fastapi-pagination<br>from fastapi_pagination import Page, add_pagination, paginate<br><br>app = FastAPI()  # create FastAPI app<br>add_pagination(app)  # important! add pagination to your app</pre><ul><li>Return “paginate” function result:</li></ul><pre>from sqlalchemy import select<br>from fastapi_pagination.ext.sqlmodel import paginate # change this to be consistent with your DB<br><br>@app.get(&quot;/users&quot;)<br>def get_users(db: Session = Depends(get_db)) -&gt; **Page[UserOut]**:<br>    return **paginate**(db, select(User).order_by(User.created_at)) # change the query based on your requirements</pre><p><em>Originally published at </em><a href="https://leviathan36.github.io/yase/rest_api_101/7_pagination/FastAPI_Pagination.html">https://leviathan36.github.io/yase/rest_api_101/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c6831fd34d2b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Security Tests for FastAPI projects]]></title>
            <link>https://medium.com/@leviathan36/security-tests-for-fastapi-projects-3cd10845b557?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/3cd10845b557</guid>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[fastapi]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Fri, 03 Oct 2025 18:22:10 GMT</pubDate>
            <atom:updated>2025-10-03T18:22:10.912Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Security is a cornerstone of REST API projects, protecting data, users, and systems from misuse or breaches. Strong authentication, authorization, and encryption ensure trust and reliability in every interaction.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q8Io6auCUcJ1KE3PcWxj_w.jpeg" /><figcaption>Security camers by <a href="https://www.pexels.com/it-it/@scottwebb/">Scott Webb</a></figcaption></figure><p>Let’s now move on to security tests, another important part of testing, especially for applications that need to be exposed externally to the internet (see previously articles <a href="https://leviathan36.github.io/yase/rest_api_101/">here</a>).</p><p>There are some easy-to-use tools that, with a little configuration, allow testing for the main security issues of a web application, achieving a good level of security with minimal effort. These tools are also open source; specifically, we’re talking about:</p><h3>Bandit</h3><p>The first is a security linter also developed by PyCQA, like Pylint.</p><p>In short, it’s a static analysis security testing (SAST) tool designed specifically to find common security issues in Python code. It doesn’t execute the code but analyzes it for patterns known to be potentially insecure.</p><p>First, it needs to be installed:</p><pre>pip install bandit</pre><p>The most common use of Bandit is to run it recursively on your project’s main directory. Bandit will analyze all .py files it finds.</p><p>If your FastAPI project is in a directory called <strong>app</strong>:</p><pre>bandit -r app/</pre><ul><li>bandit: the command to run the tool.</li><li>-r (or --recursive): tells Bandit to search for Python files recursively in the specified directory and its subdirectories.</li><li>app/: the path to your project&#39;s main directory.</li></ul><p>You can customize Bandit’s behavior through a configuration file (usually bandit.yaml or .bandit in the project root) or via command-line options.</p><p><strong>Common Use Cases for Configuration:</strong></p><ul><li><strong>Exclude Directories:</strong> ignore directories like tests, venv, or asset folders.</li></ul><pre># content of the bandit.yaml file<br>exclude_dirs: [&quot;venv&quot;, &quot;tests&quot;, &quot;.*/migrations/&quot;]<br>skips: [&#39;B101&#39;, &#39;B311&#39;] # skip these tests<br># Defines minimum levels for reports (inclusive)<br>level: &quot;MEDIUM&quot; # Options: ALL, LOW, MEDIUM, HIGH<br>confidence: &quot;MEDIUM&quot; # Options: ALL, LOW, MEDIUM, HIGH</pre><p>To get the maximum benefit, integrate Bandit into your workflow:</p><ul><li><strong>Pre-commit Hooks:</strong> run Bandit automatically before each commit. If it finds issues (above a certain threshold), the commit is blocked until they are resolved or consciously ignored. You can use the pre-commit framework. Add this to your .pre-commit-config.yaml:</li></ul><pre>repos:<br>-   repo: https://github.com/PyCQA/bandit<br>    rev: 1.7.9 # Use the latest stable version<br>    hooks:<br>    -   id: bandit<br>        args: [&quot;-c&quot;, &quot;bandit.yaml&quot;] # Optional: specify a config file</pre><p>If you want to save the scan result to a file, perhaps in JSON format, to process it later via a log aggregator and extract additional information (Grafana), you can use the “-f” and “-o” parameters like this:</p><pre>bandit -r app/ -f json -o bandit-report.json</pre><ul><li>-f json: saves in JSON format.</li><li>-o bandit-report.json: specifies the output filename.</li></ul><h3>Wapiti3</h3><p><strong>Wapiti</strong> it’s a <strong>DAST</strong> (Dynamic Application Security Testing) tool. This means it interacts with your application <em>while it’s running</em>, sending HTTP/HTTPS requests and analyzing responses to find vulnerabilities. It simulates attacks that a malicious actor might attempt.</p><p>Wapiti can search for common vulnerabilities such as:</p><ul><li>Cross-Site Scripting (XSS)</li><li>SQL Injection (SQLi)</li><li>Command Execution / Code Injection</li><li>XML External Entity (XXE) Injection</li><li>Server-Side Request Forgery (SSRF)</li><li>Local File Inclusion (LFI) / Remote File Inclusion (RFI)</li><li>And many others…</li></ul><p>First, let’s install Wapiti3:</p><pre>pip install wapiti3</pre><p>To test the application with Wapiti, you need to start it first. So, you need to run the server locally (please, never test the production app with Wapiti3 except in special, very carefully considered cases):</p><pre>fastapi run app.main.py # Or however you run your FastAPI app, e.g., uvicorn app.main:app</pre><p>I refer you to the official Wapiti3 guide to see all the possible commands, which are numerous. But, just to give you an idea, the command below can be considered the main, most generic one, suitable for a variety of situations (assuming the application is exposed on <a href="https://www.google.com/url?sa=E\&amp;source=gmail\&amp;q=http://127.0.0.1:8000/):">https://www.google.com/url?sa=E\&amp;source=gmail\&amp;q=http://127.0.0.1:8000/):</a></p><pre>wapiti -u http://127.0.0.1:8000/ \<br>-x http://127.0.0.1:8000/logout \<br>-H &quot;Authorization: Bearer &lt;YOUR_JWT_TOKEN&gt;&quot; \<br>-f json \<br>-o report_wapiti.json # Renamed output file for clarity</pre><p>As you can easily guess, the entire application will be tested, meaning all routes that Wapiti3 can find autonomously, except for “/logout” to prevent the user from being disconnected.</p><p>A valid bearer token is passed (in this case, &lt;YOUR_JWT_TOKEN&gt; should be replaced with an actual token). Everything is saved in report_wapiti.json, in JSON format, for future processing or for insertion into a dashboard (Grafana). Alternatively, for readability, the report can also be saved in HTML format, which is very convenient and easy to read.</p><p><em>Originally published at </em><a href="https://leviathan36.github.io/yase/rest_api_101/11_tests">https://leviathan36.github.io/yase/rest_api_101/11_tests</a>/</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3cd10845b557" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[API interfaces and json objects (uml class diagrams)]]></title>
            <link>https://medium.com/@leviathan36/api-interfaces-and-json-objects-uml-class-diagrams-dfb2f1941dd7?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/dfb2f1941dd7</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[json]]></category>
            <category><![CDATA[user-interface]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Sun, 28 Sep 2025 15:06:24 GMT</pubDate>
            <atom:updated>2025-09-28T15:06:24.780Z</atom:updated>
            <content:encoded><![CDATA[<p><em>API interfaces are fundamental in software development because they establish clear contracts between components, ensuring consistency and reducing ambiguity. By defining how data is exchanged, they make code easier to integrate, maintain, and scale over time.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xDFfab8Phjxculprdq0efA.jpeg" /><figcaption>json sticker by <a href="https://www.pexels.com/it-it/@realtoughcandy/">realtoughcandy</a></figcaption></figure><p>After designing the APIs on paper, choosing endpoint names, and deciding on handler functions to manage requests, we can move on to the more concrete part: writing the interfaces (see the previously articles <a href="https://leviathan36.github.io/yase/rest_api_101/">here</a>). This means defining the payloads-the json objects to be passed to the APIs and returned to the client.</p><p>These interfaces usually correspond to a database entity, as we’ve seen before. in fact, APIs often serve precisely to interface with the backend database. So, it frequently happens that these interfaces are nothing more than an object with the same attributes as the entity itself. however, in addition to the fields and data present in the db, it’s good practice to add some metadata to the api interfaces. this metadata can be useful for both the end-user (who might also be a developer) and the API programmer.</p><p>So, what’s typically done is to encapsulate the returned data in a standard data structure for that request (or for the entire system). This structure contains some additional information, such as any server-side errors that generated corrupted data or no data at all, debug messages, request timestamps, and so on.</p><p>Generally, a structured language like JSON is used for these interfaces, along with best practices for its generation, including mandatory fields that facilitate internal use and client integration. Let’s look at some of the main best practices recommended by google: <a href="https://google.github.io/styleguide/jsoncstyleguide.xml"><strong>Google best practices for rest apis</strong></a>.</p><h3>Key best practices</h3><ol><li><strong>property names:</strong></li></ol><ul><li>always use lowercamelcase format for property names (e.g., username, creationdate, listitems).</li><li><strong>meaningful and ascii:</strong> choose descriptive names and use only ascii characters. avoid uncommon abbreviations.</li><li><strong>english:</strong> prefer english names for greater interoperability, unless the API is strictly limited to a narrow, national context.</li></ul><p><strong>2. property values &amp; data types:</strong></p><ul><li><strong>standard types:</strong> use standard json data types (string, number, boolean, object, array, null).</li><li><strong>dates and times:</strong> represent dates, times, and timestamps as strings in <strong>iso 8601</strong> format (e.g., &quot;2025-03-28t08:21:58z&quot; or &quot;2025-03-28&quot;). use utc (z) whenever possible to avoid timezone ambiguities.</li><li><strong>durations/intervals:</strong> represent durations or amounts of time as a number (preferably in seconds or milliseconds, specifying the unit in the property name, e.g., durationseconds) or as an <strong>iso 8601 duration</strong> format string (e.g., &quot;p3dt6h4m&quot;).</li><li><strong>enumerations (enum):</strong> represent enumeration values as string. choose meaningful string values (e.g., &quot;pending&quot;, &quot;completed&quot;).</li><li><strong>empty/absent values:</strong> use null to explicitly indicate the absence of a value. avoid using empty strings (&quot;&quot;) for this purpose, unless an empty string is a valid value distinct from null. consider completely omitting optional properties if they don&#39;t have a value.</li><li><strong>binary data:</strong> encode binary data using <strong>base64</strong> and include it as a string.</li></ul><p><strong>3. json structure:</strong></p><ul><li><strong>top-level object:</strong> json responses should always consist of an object ({}) or, less commonly if appropriate, an array ([]) as the root structure. it&#39;s often useful to use a root object even for collections (e.g., { &quot;items&quot;: [...] }) to easily add metadata (like pagination information: totalitems, nextpagetoken, etc.).</li><li><strong>consistency:</strong> maintain a consistent structure and naming convention throughout the API to make it easier to use.</li></ul><p><strong>Which fields should you include at a minimum:</strong></p><ol><li><strong>for general context and success:</strong></li></ol><ul><li>data (or payload, result, items, etc.): a container field for the &quot;actual&quot; requested data. using a wrapper like this allows you to add other fields at the same level without mixing them with the main data. JSON</li><li>{ &quot;data&quot;: { &quot;userid&quot;: 123, &quot;name&quot;: &quot;john doe&quot; } }</li><li>message / msg: a human-readable string providing a brief message about the operation&#39;s status (e.g., &quot;user created successfully,&quot; &quot;data updated&quot;). useful for both successes and errors, and for display on a potential frontend.</li><li>timestamp: the date and time (preferably in iso 8601 utc format) when the response was generated by the server. useful for logging and caching.</li><li>requestid: a unique identifier for the specific request/response. very useful for tracking and debugging across client and server logs.</li><li>apiversion: the version of the API that handled the request.</li><li>executiontimems: the time taken by the server to process the request (useful for performance monitoring).</li></ul><p><strong>2. for detailed error handling (typical with 4xx/5xx status codes):</strong></p><ul><li>error: an object container for all error details.</li><li>errorcode / code: an <strong>application-specific</strong> code (string or number, e.g., &quot;validation_error&quot;, &quot;auth_failed&quot;, 10021) that uniquely identifies the error programmatically. it’s distinct from the http status code but provides more detail.</li><li>errormessage / message / detail: a <strong>human-readable</strong> description of the specific error that occurred.</li><li>errors / details: an array of objects, useful when there are <strong>multiple errors</strong> (e.g., validation errors on multiple input fields). each object can contain details like field (the field with the error), code (field-specific code), message (field-specific message).</li></ul><pre>{<br>    &quot;error&quot;: {<br>      &quot;code&quot;: &quot;validation_error&quot;,<br>      &quot;message&quot;: &quot;invalid input.&quot;,<br>      &quot;details&quot;: [<br>        { &quot;field&quot;: &quot;email&quot;, &quot;code&quot;: &quot;invalid_format&quot;, &quot;message&quot;: &quot;invalid email format.&quot; },<br>        { &quot;field&quot;: &quot;age&quot;, &quot;code&quot;: &quot;value_too_low&quot;, &quot;message&quot;: &quot;age must be greater than 18.&quot; }<br>      ]<br>    }<br>  }</pre><p>You can consider extending the fields of the “error” container object by following the <strong>rfc 7807 standard</strong> “problem details for http apis” (rfc 7807), which defines fields like type, title, status, detail, instance. here’s an example from the standard:</p><pre>{<br>    &quot;type&quot;: &quot;https://example.com/probs/insufficient-funds&quot;,<br>    &quot;title&quot;: &quot;insufficient funds&quot;,<br>    &quot;status&quot;: 403,<br>    &quot;detail&quot;: &quot;your account balance is 30, but the transaction requires 50.&quot;,<br>    &quot;instance&quot;: &quot;/account/12345/transactions/67890&quot;<br>  }</pre><p>To integrate it, you could do something like this:</p><pre> {<br>    &quot;error&quot;: {<br>      &quot;code&quot;: &quot;validation_error&quot;,  // same as status<br>      &quot;title&quot;: &quot;insufficient funds&quot;,  // short title<br>      &quot;message&quot;: &quot;invalid input.&quot;, // long description, substitutes detail<br>      &quot;details&quot;: [<br>        { &quot;field&quot;: &quot;email&quot;, &quot;code&quot;: &quot;invalid_format&quot;, &quot;message&quot;: &quot;invalid email format.&quot; },<br>        { &quot;field&quot;: &quot;age&quot;, &quot;code&quot;: &quot;value_too_low&quot;, &quot;message&quot;: &quot;age must be greater than 18.&quot; }<br>      ],<br>      &quot;helpurl&quot;: &quot;https://example.com/probs/insufficient-funds&quot;, // replaces &quot;type&quot;<br>      &quot;instance&quot;: &quot;/account/12345/transactions/67890&quot; // points to the resource if it exists<br>    }<br>  }</pre><ul><li>helpurl / documentationurl: a link to documentation explaining the error and how to resolve it.</li></ul><p><strong>3. for pagination (when returning collections/lists):</strong></p><ul><li>page / pagenumber: the current page number being returned.</li><li>pagesize / limit: the number of items per page.</li><li>totalitems / totalcount: the total number of items available in the entire collection (across all pages).</li><li>totalpages: the total number of pages available.</li><li>nextpagetoken / continuationtoken: an opaque token for cursor-based pagination (alternative/complement to pagenumber).</li><li>_links (hateoas style): an object containing hypermedia links, including those for the next (next), previous (prev), first (first), and last (last) pages.</li></ul><p><strong>Important considerations:</strong></p><ul><li><strong>use http status codes correctly:</strong> metadata in the json body should <em>complement</em>, not replace, the correct use of http status codes. a client error should return a 4xx status (e.g., 400 bad request, 404 not found), and a server error should return a 5xx status (500 internal server error). don&#39;t return 200 ok with an error message in the body.</li><li><strong>consistency:</strong> choose a standard structure for your responses (both success and error) and use it <em>consistently</em> throughout your API. this greatly facilitates integration by clients.</li></ul><p>In summary, including a wrapper with metadata like data, error (with code, message, details), requestid, and pagination fields makes rest APIs more robust, user-friendly, and maintainable.</p><h4>Let’s put it all together:</h4><pre># example of a complete response<br>{<br>  &quot;data&quot;: {<br>    &quot;userid&quot;: 123,<br>    &quot;name&quot;: &quot;john doe&quot;<br>  },<br>  &quot;message&quot;: &quot;user found&quot;,<br>  &quot;timestamp&quot;: &quot;2020-07-10 15:00:00.000&quot;,<br>  &quot;requestid&quot;: &quot;rdxkm65&quot;,<br>  &quot;apiversion&quot;: &quot;v1&quot;,<br>  &quot;executiontimems&quot;: 300,<br>  &quot;page&quot;: 1,<br>  &quot;limit&quot;: 1,<br>  &quot;totalitems&quot;: 1<br>}</pre><p>In case of an error:</p><pre>{<br>  &quot;timestamp&quot;: &quot;2021-07-10 15:00:00.000&quot;,<br>  &quot;requestid&quot;: &quot;rdxkd345&quot;,<br>  &quot;apiversion&quot;: &quot;v1&quot;,<br>  &quot;executiontimems&quot;: 121,<br>  &quot;error&quot;: {<br>      &quot;code&quot;: &quot;validation_error&quot;,  // same as status<br>      &quot;title&quot;: &quot;insufficient funds&quot;,  // short title<br>      &quot;message&quot;: &quot;invalid input.&quot;, // long description, substitutes detail<br>      &quot;details&quot;: [<br>        { &quot;field&quot;: &quot;email&quot;, &quot;code&quot;: &quot;invalid_format&quot;, &quot;message&quot;: &quot;invalid email format.&quot; },<br>        { &quot;field&quot;: &quot;age&quot;, &quot;code&quot;: &quot;value_too_low&quot;, &quot;message&quot;: &quot;age must be greater than 18.&quot; }<br>      ],<br>      &quot;helpurl&quot;: &quot;https://example.com/probs/insufficient-funds&quot;, // replaces &quot;type&quot;<br>      &quot;instance&quot;: &quot;/account/12345/transactions/67890&quot; // points to the resource if it exists<br>    }<br>}</pre><p>If the data field is present, then the http return code will be a success code, and the error container will not be present; otherwise, the error container will be present, and not the data one.</p><p>It’s advisable to include only one of the two fields, data or error, based on the http response code. if the http code indicates success (e.g., 200 ok), use the data field. if, however, the http code indicates an error (e.g., 4xx or 5xx), use the error field. this approach keeps the payload structure clear and consistent.</p><p><em>Originally published at </em><a href="https://leviathan36.github.io/yase/rest_api_101/">https://leviathan36.github.io/yase/rest_api_101/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dfb2f1941dd7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[API Design (what no one does)]]></title>
            <link>https://medium.com/@leviathan36/api-design-what-no-one-does-2ff9d8730e76?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ff9d8730e76</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Wed, 24 Sep 2025 17:51:47 GMT</pubDate>
            <atom:updated>2025-09-24T17:51:47.086Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>✨ Good API design is crucial for building reliable, scalable, and user-friendly systems.<br> 🔗 Well-designed APIs simplify integration, reduce errors, and ensure long-term maintainability.</blockquote><blockquote>………………………………………………………………………………. cit. ChatGPT</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I0kiTqTrBOer1nvhtbWREQ.jpeg" /><figcaption>Architect by <a href="https://www.pexels.com/it-it/@lexovertoom/">lexovertoom</a></figcaption></figure><p>To figure out which endpoints you need, there are a few different approaches you can take:</p><ul><li>Start with the ER model of the backend database. Determine which entities and relationships you want to expose externally through APIs, and then create the corresponding routes. Generally, these routes will implement CRUD methods for those entities.</li><li>Begin by analyzing the application’s use case diagram. From this, identify the processes and actions you want to make available to the user, and create APIs for them. In this approach, the focus is more on actions and processes rather than the data stored in the database.</li><li>You might simply need to expose functions or utilities externally. These functions don’t necessarily interact with a database and are therefore stateless: they take input data, perform some processing, and return an output value.</li></ul><p>In the first scenario, you’d have an ER model where the entities roughly correspond to the tables in your database. These tables then become the entities for your REST APIs.</p><p>You could model the database, or just the entities you want to expose, using a UML class diagram:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/783/0*SCmqRItm2EVhfRfe.png" /></figure><p>This image clearly shows how entities are mapped (almost one-to-one) to objects in the UML diagram. These objects then serve as the inputs/outputs for the functions, or routes, of your REST endpoints.</p><p>In this specific case, some common UML stereotypes for REST API engineering are used:</p><ul><li><strong>application</strong>: this block defines the <strong>general structure of the response</strong> (envelope) that the API might return, rather than a specific resource. It can, and should, define some attributes or metadata surrounding the requested data, such as:</li><li>code: likely a numeric code (like an HTTP status code or an application-specific error code) indicating the operation&#39;s outcome.</li><li>type: a string that could categorize the response type (e.g., &quot;success&quot;, &quot;error&quot;, &quot;validation&quot;).</li><li>message: a human-readable string providing details about the operation&#39;s outcome or any errors.</li><li>and others that we’ll look at later.</li></ul><pre># &lt;&lt;Application&gt;&gt; SomeAPI<br>  -----------------------------------------------------------------<br>  code: int # HTTP return code<br>  type: str<br>  message: str<br>  items: dict # iterable with all data<br>  ...</pre><p>Even the envelope itself requires coding a specific object, which, however, doesn’t belong to the database entities but is exclusive to the application, particularly the APIs.</p><ul><li><strong>path</strong>: indicates the route or sub-route name, like in user/balance.</li><li><strong>use</strong>: shows that an object is used by an API.</li><li><strong>representation</strong>: corresponds to the objects or entities you want to manage with the endpoints.</li><li><strong>resource</strong>: acts as a container for the methods and specific attributes of a route.</li></ul><pre># &lt;&lt;Resource&gt;&gt; Order<br>  + GET(order_id: int): Order<br>  - POST(order_id: int, order_name: str, amount: float): Order</pre><p>This is an example of a possible implementation for the Order resource:</p><ul><li>The first method, GET, returns the details (i.e., the object itself) of the order based on its ID and is publicly accessible (+) without needing authentication (unlikely in a real scenario, LOL).</li><li>The second method, POST, requires authentication (-) and takes 3 input parameters. Parameters in POST requests are passed in the body. Both functions (endpoints) return an Order object (which will be specified in a red “Representation” block declared somewhere).</li></ul><p>The “Resource” blocks can be extended by adding attributes to specify properties calculated internally by the function handling that endpoint, which aren’t part of the object returned by the route itself. In other words, these attributes are additional metadata surrounding the data returned by the route, fields of the envelope itself, similar to what was done with the “Application” block:</p><pre># &lt;&lt;Resource&gt;&gt; Order<br>----------------------------------------------------------------------------------<br>n_orders: int # total orders<br>----------------------------------------------------------------------------------<br>+ GET(order_id: int): Order<br>+ GET(): List[Order]<br>- POST(order_id: int, order_name: str, amount: float): Order</pre><p>Resource attributes, being calculated by the route-handling function rather than taken directly from the database, generally don’t have a state; they aren’t saved or tracked. They are just data pre-calculated by the server for convenience and are useful on the client side. They act as on-the-spot “statistics” for the just-returned data; saving them would be redundant in the database.</p><p>Next, let’s look at how to structure the names of APIs and resources, and what naming conventions to follow.</p><p><em>Originally published at </em><a href="https://leviathan36.github.io/yase/rest_api_101/0_API_Design/api_design.html">https://leviathan36.github.io/yase/rest_api_101/0_API_Design/api_design.html</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ff9d8730e76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reclaiming the Web: How Community-Driven Networks Are Building an Independent Internet ]]></title>
            <link>https://medium.com/@leviathan36/reclaiming-the-web-how-community-driven-networks-are-building-an-independent-internet-ff551a17bb73?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff551a17bb73</guid>
            <category><![CDATA[internet-of-things]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[network]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Tue, 20 May 2025 05:41:39 GMT</pubDate>
            <atom:updated>2025-05-20T05:41:39.019Z</atom:updated>
            <content:encoded><![CDATA[<h3>Reclaiming the Web: How Community-Driven Networks Are Building an Independent Internet</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lMAVgCydDUDzpDk-Jp3UJg.jpeg" /><figcaption>Web of a spider by <a href="https://www.pexels.com/it-it/@chivozol-43727/">chivozol</a></figcaption></figure><p>The internet, once a beacon of open access and free information, is increasingly dominated by a few large corporations and restricted by the economic interests of Internet Service Providers (ISPs). This centralization leaves vast swathes of the global population, particularly in remote or economically marginalized regions like many African villages, without reliable or affordable access. But a new wave of technological innovation, driven by a philanthropic spirit and a desire for digital independence, is challenging this status quo. Enter the world of mesh networks, peer-to-peer (P2P) systems, and community-driven internet solutions — a lifeline for connectivity and a stand against Big Tech dominance.</p><p>These groundbreaking projects are not just about providing an internet connection; they are about fostering self-reliance, ensuring privacy, and building resilient communication infrastructures that are inherently resistant to censorship and control. Let’s dive into the technical marvels making this possible.</p><h3>The Technical Pillars of a Decentralized Internet</h3><p>At the heart of these independent networks are a few core technological principles:</p><ul><li><strong>Mesh Networks:</strong> Imagine a network where every device (or node) can connect to every other nearby device, rather than relying on a central point like a traditional Wi-Fi router or cell tower. This is the essence of a mesh network. Data packets hop from node to node until they reach their destination. If one node fails or goes offline, the network automatically reroutes traffic through other available nodes. This creates a self-healing, highly resilient system. Technologies often involve Wi-Fi (e.g., 802.11s), Bluetooth, or specialized radio protocols like LoRa.</li><li><strong>Peer-to-Peer (P2P) Systems:</strong> Building upon the decentralized nature of mesh networks, P2P protocols allow direct communication and data sharing between users without intermediaries. This is fundamental for services like censorship-resistant publishing, secure messaging, and distributed data storage. Instead of relying on central servers that can be shut down or monitored, data is distributed across the network participants.</li><li><strong>No Single Point of Failure:</strong> By distributing network functions, data, and connectivity across many nodes, these systems eliminate single points of failure. The failure of one or even several nodes typically doesn’t bring down the entire network, a stark contrast to centralized ISP architectures where an outage at a local exchange can disconnect thousands.</li><li><strong>Community Driven:</strong> Perhaps the most crucial aspect is the human element. These networks are often built, maintained, and governed by the communities they serve. This grassroots approach ensures that the network meets local needs and fosters a sense of ownership and digital empowerment. Open-source software and affordable hardware are key enablers.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u7MzP7L8P6-YoDK5Jzk-gA.jpeg" /><figcaption>Development board by <a href="https://www.pexels.com/it-it/@lishadunlap/">Lisha Dunlap</a></figcaption></figure><h3>Spotlight on Pioneering Projects</h3><p>Several inspiring projects are leading the charge in creating these alternative networks:</p><h3>1. Freenet: The Censorship-Resistant Haven</h3><p><strong>Website:</strong> <a href="https://freenet.org/">https://freenet.org/</a></p><ul><li><strong>Technical Deep Dive:</strong> Freenet is a peer-to-peer platform for censorship-resistant communication and publishing. It’s essentially a decentralized, distributed data store. When you store a file in Freenet, it’s encrypted and split into pieces, then distributed across multiple nodes in the network. To retrieve it, you only need the key. Neither the storers nor the retrievers (beyond direct neighbors in the network) can easily identify each other or the content’s origin/destination.</li><li><strong>Anonymity Layers:</strong> It operates in “darknet” mode (connecting only to trusted friends, enhancing anonymity) or “opennet” mode (connecting to other random Freenet users).</li><li><strong>Content Publishing:</strong> Users can publish “freesites” — websites accessible only through Freenet — which are highly resistant to takedowns.</li><li><strong>Decentralized Storage:</strong> It doesn’t rely on central servers, making it incredibly resilient. Data persistence is probabilistic, depending on popularity and how many users are “hosting” parts of it.</li></ul><h3>2. Meshtastic: Off-Grid, Long-Range Communication</h3><p><strong>Website:</strong> <a href="https://meshtastic.org/">https://meshtastic.org/</a></p><ul><li><strong>Technical Deep Dive:</strong> Meshtastic is an open-source project that enables off-grid, decentralized, and encrypted mesh communication using low-power, long-range LoRa (Long Range) radios. It’s ideal for hikers, preppers, or communities where cellular/internet is unavailable or unreliable.</li><li><strong>LoRa Technology:</strong> Utilizes Semtech LoRa chips, which allow for communication over several kilometers (or even tens of kilometers with line-of-sight) with very low power consumption. This means devices can run for days or weeks on small batteries.</li><li><strong>Mesh Networking:</strong> Each Meshtastic device acts as a node in a mesh network, relaying messages for others to extend range. It supports text messaging, GPS location sharing, and sensor data telemetry.</li><li><strong>Hardware:</strong> Typically runs on inexpensive ESP32-based development boards paired with LoRa modules, making it highly accessible.</li><li><strong>Community Focus:</strong> Designed to be “easy to use and useful for a community,” emphasizing a decentralized, user-owned infrastructure.</li></ul><h3>3. LibreMesh: Building Community Wi-Fi Networks</h3><p><strong>Website:</strong> <a href="https://libremesh.org/">https://libremesh.org/</a></p><ul><li><strong>Technical Deep Dive:</strong> LibreMesh is an open-source framework for creating self-managed Wi-Fi mesh networks. It’s built upon OpenWrt (a Linux distribution for embedded devices like routers) and incorporates various mesh routing protocols.</li><li><strong>OpenWrt Foundation:</strong> By leveraging OpenWrt, LibreMesh can run on a wide variety of off-the-shelf Wi-Fi routers, turning them into powerful mesh nodes.</li><li><strong>Mesh Routing Protocols:</strong> Often uses protocols like B.A.T.M.A.N. Advanced (Better Approach To Mobile Adhoc Networking) or OLSR (Optimized Link State Routing Protocol) to efficiently route traffic through the mesh.</li><li><strong>Community Empowerment:</strong> LibreMesh aims to simplify the creation and maintenance of local community networks, allowing neighborhoods or villages to build their own internet infrastructure. It includes features for network monitoring and management.</li><li><strong>Use Cases:</strong> Particularly popular for community networks in both urban and rural areas where traditional internet is expensive, unreliable, or unavailable.</li></ul><h3>The Philanthropic Drive for Digital Independence</h3><p>These projects, and many others like them, are often born from a deep-seated belief in the free flow of information and the right to communication. They represent a significant departure from the profit-driven models of Big Tech and traditional ISPs. By empowering communities to build and manage their own digital infrastructure, they foster local expertise, economic opportunities, and a profound sense of independence.</p><p>The philanthropic spirit embedded in these initiatives is crucial for bridging the digital divide, offering lifelines to underserved populations, and ensuring that the internet remains a tool for liberation, not just commerce.</p><h3>Discover More: TechXgood</h3><p>The projects highlighted above are just the tip of the iceberg. For those inspired to explore further or contribute to the burgeoning field of technology for social good, an invaluable resource awaits.</p><p>The <strong>TechXgood</strong> website, found <a href="https://techxgood.github.io/techxgood/index.html">here</a>, serves as a curated directory of innovative projects, tools, and communities dedicated to leveraging technology for positive global impact.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wZrxZTh1OiSoTcQvDtB0Yg.png" /><figcaption>TechXgood logo</figcaption></figure><p><strong>Brief Review of Tech X Good:</strong></p><p>The <strong>TechXgood </strong>platform is a well-organized and insightful portal that showcases a diverse range of initiatives. From tools promoting digital security and open access to information, to projects tackling environmental challenges and social justice, techxgood.github.io offers a panoramic view of how technology can be a force for good.</p><ul><li><strong>Ease of Navigation:</strong> The site is clearly laid out, making it easy to browse different categories and discover projects relevant to specific interests.</li><li><strong>Focus:</strong> It highlights open-source projects and community-driven efforts, aligning perfectly with the ethos of digital independence and decentralized solutions discussed in this article.</li><li><strong>Value for Users:</strong> Whether you’re a developer looking to contribute your skills, a community organizer seeking solutions, or simply an individual passionate about technology’s potential to solve real-world problems, <strong>TechXgood</strong> provides a fantastic starting point. It’s a testament to the power of collaborative innovation.</li></ul><p>By visiting <a href="https://techxgood.github.io/techxgood/index.html"><strong>https://techxgood.github.io/techxgood/index.html</strong></a>, you can explore a wider array of projects aimed at creating a more equitable, connected, and empowered world. This directory is an excellent resource for anyone looking to delve deeper into the world of community networks, ISP independence, and technology designed for the betterment of society.</p><h3>Paving the Way for a Truly Global Web</h3><p>The journey towards a universally accessible and independent internet is ongoing. Projects like Freenet, Meshtastic, and LibreMesh demonstrate that with technical ingenuity and a community-first approach, it’s possible to overcome geographical and economic barriers. They are not just building networks; they are weaving a new fabric for global communication — one that is more resilient, equitable, and empowering for all.</p><p>Explore these technologies, support these communities, and discover more ways to get involved through resources like <a href="https://techxgood.github.io/techxgood/index.html"><strong>techXgood</strong></a>. The future of the internet is what we collectively build.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff551a17bb73" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Big Tech: Three Open Source Projects Reclaiming Our Digital Lives (And Where to Find More) ]]></title>
            <link>https://medium.com/@leviathan36/beyond-big-tech-three-open-source-projects-reclaiming-our-digital-lives-and-where-to-find-more-965b7d34ad37?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/965b7d34ad37</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[search-engines]]></category>
            <category><![CDATA[philanthropy]]></category>
            <category><![CDATA[environment]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Fri, 16 May 2025 06:26:42 GMT</pubDate>
            <atom:updated>2025-05-16T06:26:42.820Z</atom:updated>
            <content:encoded><![CDATA[<h3>Beyond Big Tech: Three Open Source Projects Reclaiming Our Digital Lives (And Where to Find More)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CcLBNPrYD9bex51pvpCOZQ.jpeg" /><figcaption>Typewriter by <a href="https://www.pexels.com/it-it/@markus-winkler-1430818/">Markus Winkler</a></figcaption></figure><p>In a digital landscape dominated by a handful of tech giants, it’s easy to feel like our online experiences are dictated by profit motives and opaque algorithms. But what if there was another way? What if technology could be built <em>by</em> the people, <em>for</em> the people, prioritizing privacy, community, and genuine connection over engagement metrics and ad revenue?</p><p>The good news is, this isn’t just a hypothetical scenario. A vibrant ecosystem of open-source projects is steadily growing, offering powerful alternatives that empower individuals and improve lives. These initiatives are a clear signal that we can, indeed, choose a different path, bypassing the traditional capitalist structures of Big Tech.</p><p>Let’s dive into three shining examples of how open-source is making a tangible difference:</p><h3>1. Mastodon: Social Networking Reimagined</h3><p><strong>Website:</strong> <a href="https://joinmastodon.org/">https://joinmastodon.org/</a></p><p>Tired of the echo chambers, intrusive advertising, and a single corporation controlling your social feed? <strong>Mastodon</strong> offers a refreshing alternative. It’s not one giant website, but a <strong>decentralized social network</strong> made up of thousands of independently run servers (called “instances”), all interconnected through a common protocol called ActivityPub.</p><p><strong>How it helps people:</strong></p><ul><li><strong>Community Ownership:</strong> Each instance can have its own rules, moderation policies, and community focus. This means you can find or create a space that truly aligns with your interests and values.</li><li><strong>No Algorithmic Manipulation:</strong> Your timeline is chronological. You see posts from people you follow, as they happen, without algorithms deciding what’s “relevant” for you.</li><li><strong>Ad-Free &amp; Privacy-Focused:</strong> Mastodon is non-profit and ad-free. Its decentralized nature makes it much harder for any single entity to harvest and monetize your data on a massive scale. It puts you back in control of your social experience.</li><li><strong>Interoperability:</strong> Thanks to ActivityPub, Mastodon can interact with other decentralized platforms, creating a more open and interconnected social web (the “fediverse”).</li></ul><p>Mastodon is a testament to the idea that social media can be a tool for genuine connection and diverse communities, rather than a platform for corporate surveillance and engagement hacking.</p><h3>2. Signal: Private Communication, Uncompromised</h3><p><strong>Website:</strong> <a href="https://signal.org/">https://signal.org/</a></p><p>In an era where digital surveillance is a constant concern, <strong>Signal</strong> stands as a beacon for private and secure communication. This open-source messaging app, developed by the non-profit Signal Foundation, offers <strong>end-to-end encryption</strong> by default for all messages, voice calls, and video calls.</p><p><strong>How it helps people:</strong></p><ul><li><strong>Unbreakable Privacy:</strong> Only you and your intended recipient(s) can read your messages or hear your calls. Not even Signal itself can access your communications.</li><li><strong>Transparency:</strong> Being open source means its code is available for anyone to inspect, verify, and contribute to. This builds trust and ensures there are no hidden backdoors.</li><li><strong>Focus on Communication, Not Data:</strong> Signal’s mission is to provide secure communication, not to collect user data for advertising or other purposes. Its development is funded by grants and donations.</li><li><strong>Ease of Use:</strong> Despite its powerful security features, Signal is designed to be as user-friendly as any mainstream messaging app.</li></ul><p>Signal empowers individuals — from journalists and activists to everyday citizens — to communicate freely and securely, knowing their conversations are protected from prying eyes. It’s a critical tool for protecting freedom of expression and personal privacy.</p><h3>3. CKAN: Powering Open Data and Transparency</h3><p><strong>Website:</strong> <a href="https://ckan.org/">https://ckan.org/</a></p><p>Knowledge is power, and <strong>CKAN (Comprehensive Knowledge Archive Network)</strong> is an open-source Data Management System (DMS) dedicated to making data accessible to everyone. It’s the leading platform behind countless open data portals run by governments, research institutions, and organizations worldwide.</p><p><strong>How it helps people:</strong></p><ul><li><strong>Democratizing Data:</strong> CKAN makes it easy for organizations to publish, share, and manage their datasets. This allows citizens, researchers, journalists, and businesses to find and use valuable information.</li><li><strong>Fostering Transparency and Accountability:</strong> When governments use CKAN to publish data on public spending, services, and outcomes, it fosters transparency and allows citizens to hold them accountable.</li><li><strong>Driving Innovation:</strong> Access to open data fuels innovation. Developers can build new applications, researchers can make new discoveries, and businesses can create new services, all powered by freely available information.</li><li><strong>Collaboration and Community:</strong> As an open-source project, CKAN benefits from a global community of developers and users who contribute to its improvement and help organizations implement it.</li></ul><p>CKAN is a foundational piece of infrastructure for a more informed and data-driven society, enabling better decision-making and empowering communities with the information they need.</p><h3>The Common Thread: People-Powered Alternatives</h3><p>Mastodon, Signal, and CKAN are more than just software; they represent a movement. They demonstrate that when people come together with a shared vision, driven by principles of openness, privacy, and community benefit, they can create powerful tools that challenge the dominance of profit-driven Big Tech.</p><p>These projects, and many others like them, prove that technology can be a force for good, designed to serve humanity rather than exploit it.</p><h3>Discover More: TechXGood</h3><p>If these examples have inspired you, you’ll be pleased to know there’s a place where you can discover even more such initiatives.</p><p><strong>Website:</strong> <a href="https://techxgood.github.io/techxgood/index.html">https://techxgood.github.io/techxgood/index.html</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wZrxZTh1OiSoTcQvDtB0Yg.png" /><figcaption>TechXgood logo</figcaption></figure><p>The <strong>TechXGood</strong> website serves as a valuable directory for open-source projects designed to have a positive impact on people’s lives and society as a whole. It’s a curated collection that helps you navigate the vast landscape of open-source software and find tools that align with ethical principles and a desire for a better digital future.</p><p><strong>A Quick Review of TechXGood:</strong></p><p>The site presents a straightforward, categorized list of projects, making it easy to explore different areas where open-source is making a difference — from communication and social media to data management, education, and health. Each listing typically provides a brief description and a link to the project’s homepage.</p><p>While simple in its design, TechXGood’s strength lies in its focused mission: to highlight technology that serves a genuine human need or promotes a social good. It’s a fantastic starting point for anyone looking to:</p><ul><li>Decentralize their digital life.</li><li>Enhance their privacy and security.</li><li>Support community-driven initiatives.</li><li>Find ethical alternatives to mainstream software.</li></ul><p>It’s a reminder that the “good” in technology isn’t just about flashy features, but about its fundamental impact on our freedom, our communities, and our ability to shape our own digital experiences.</p><h3>The Future is Open</h3><p>The journey away from a purely profit-driven tech landscape is ongoing, but the path is being paved by projects like Mastodon, Signal, CKAN, and the many others showcased on resources like TechXGood. By supporting, using, and contributing to these open-source alternatives, we can all play a part in building a more equitable, transparent, and empowering digital world for everyone. The power to choose is increasingly in our hands.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=965b7d34ad37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TechXgood: open source projects search engine ]]></title>
            <link>https://medium.com/@leviathan36/techxgood-open-source-projects-search-engine-e2afab15bd7d?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2afab15bd7d</guid>
            <category><![CDATA[environment]]></category>
            <category><![CDATA[crawler]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[python3]]></category>
            <category><![CDATA[philanthropy]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Tue, 13 May 2025 06:32:30 GMT</pubDate>
            <atom:updated>2025-05-13T06:32:30.915Z</atom:updated>
            <content:encoded><![CDATA[<h3>TechXgood: open source projects search engine</h3><p><em>A technical look at its GitHub-Powered philanthropic project crawler.</em> <em>Discover how TechXgood leverages a Python crawler and GitHub Actions to find open source philanthropic projects.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sg-Y_YT68P9bjOWGayzMCw.jpeg" /><figcaption>excavator by <a href="https://www.pexels.com/it-it/@parinduan/">Idi Parinduan</a></figcaption></figure><p>The TechXgood initiative champions philanthropic open-source projects, building its platform entirely on a cost-free GitHub infrastructure. This article offers a technical deep dive into a cornerstone of its operation: the crawler.py Python script, responsible for the automated discovery and curation of projects featured on <a href="https://techxgood.github.io/techxgood/">TechXgood&#39;s website</a>. We&#39;ll explore how this script, hosted on the <a href="https://github.com/techXgood/techXgood">TechXgood GitHub repository</a>, powers a unique, serverless backend.</p><h3>The challenge: curating open source for Philanthropy</h3><p>Identifying impactful, philanthropic open-source projects within GitHub’s vast ecosystem is a significant challenge. TechXgood tackles this by automating the discovery process. The crawler.py script, a key component of the <a href="https://github.com/techXgood/techXgood">TechXgood open source project</a>, is engineered to systematically find, vet, and prepare these projects for showcase.</p><h3>Under the hood: the crawler.py script from the TechXgood GitHub repository</h3><p>The crawler.py script forms the intelligent core of TechXgood&#39;s content pipeline. Let&#39;s examine its technical architecture and key code highlights, all available for review in the <a href="https://github.com/techXgood/techXgood">TechXgood GitHub repository</a>.</p><p><strong>1. Core Python dependencies for web crawling and data integrity:</strong></p><p>The script effectively utilizes several Python libraries:</p><ul><li>requests: for all HTTP interactions with the GitHub API.</li><li>pydantic: inferred from ValidationError and validate_repo_info, Pydantic models likely ensure that data fetched from GitHub adheres to TechXgood&#39;s internal data structure (data.datamodel.validate_repo_info), crucial for consistency.</li><li>beartype: provides runtime type checking via the @beartype decorator, enhancing code robustness for this Python crawler.</li><li>json: employed for managing the projects.json &quot;database&quot; and the status.json file, which tracks the crawler&#39;s search progress across various philanthropic keywords.</li></ul><p><strong>2. The TechXgood crawler’s operational workflow:</strong></p><p>The main function in crawler.py (found in the <a href="https://github.com/techXgood/techXgood">TechXgood GitHub repository</a>) orchestrates the project discovery:</p><ul><li><strong>Stateful keyword searching:</strong> TechXgood’s crawler uses a backend/crawler/status.json file to manage its search state across different keywords and pagination. This allows for efficient, resumable searches for philanthropic open source projects.</li></ul><pre># Simplified from crawler.py in the TechXgood GitHub repository<br># Manages search status for keywords to find philanthropic projects<br>with open(&#39;backend/crawler/status.json&#39;, &quot;r&quot;) as status_file:<br>    status = json.load(status_file)<br># ...<br>repository_urls_list = search_projects_on_github(<br>    keywords=first_kw_item[&quot;kw&quot;].split(&#39; &#39;),<br>    page=int(first_kw_item[&quot;status&quot;]),<br>    # ...<br>)<br># ...<br>first_kw_item[&quot;status&quot;] += 1 <br># ...<br>with open(&#39;backend/crawler/status.json&#39;, &quot;w&quot;) as status_file:<br>    json.dump(status, status_file)</pre><p><em>SEO Highlight: This iterative search mechanism, using keywords relevant to “tech for good” and “philanthropic software,” is central to how the </em><a href="https://github.com/techXgood/techXgood"><em>TechXgood GitHub project</em></a><em> populates its database.</em></p><ul><li><strong>Preventing duplicate entries:</strong> the already_in function checks against projects.json to ensure each philanthropic project is unique in the TechXgood showcase.</li><li><strong>Data extraction and pydantic validation:</strong> extract_info_from_repo fetches repository details, which are then validated by validate_repo_info against TechXgood&#39;s Pydantic data models.</li><li><strong>Identifying philanthropic projects (labeling logic):</strong> The repository_labeling function is critical. It analyzes a repository&#39;s title, description, and README to categorize its purpose. Projects are selected if their label is not &#39;other&#39;, indicating a fit for TechXgood&#39;s philanthropic criteria.</li></ul><pre># From crawler.py - see the full code on the TechXgood GitHub repository<br># Determines if an open source project is philanthropic<br>label = repository_labeling(<br>    valid_repo.title,<br>    valid_repo.description,<br>    repo_readme<br>)<br>if label != &#39;other&#39;: # key filter for philanthropic projects<br>    valid_repo.keywords += extract_kw(...) <br>    valid_repo.category = label<br>    valid_repositories.append(valid_repo.model_dump())</pre><ul><li><strong>Enhanced keyword extraction:</strong> for relevant philanthropic projects, extract_kw pulls additional keywords, improving discoverability within the TechXgood platform.</li><li><strong>JSON data persistence:</strong> validated projects are stored in data/projects.json, showcasing a simple yet effective database solution for this GitHub Pages-hosted site.</li><li><strong>Runtime type safety with </strong><strong>beartype:</strong> the @beartype decorator in this Python script helps maintain code quality by catching type errors early.</li><li><strong>Authenticated GitHub API usage:</strong> the crawler uses a gh_token for authenticated GitHub API requests, crucial for handling rate limits during extensive searches for open source projects.</li></ul><p><strong>3. GitHub Actions: the “Serverless Backend” for TechXgood’s crawler</strong></p><p>The crawler.py script is brought to life by GitHub Actions, forming TechXgood&#39;s serverless backend:</p><ol><li><strong>Scheduled crawler execution:</strong> A GitHub Actions workflow (defined in the .github/workflows/ directory of the <a href="https://github.com/techXgood/techXgood">TechXgood GitHub repository</a>) runs crawler.py automatically.</li><li><strong>Data file updates:</strong> The Python crawler updates data/projects.json with new philanthropic open source finds.</li><li><strong>Automated commits:</strong> The GitHub Action commits the updated JSON data back to the <a href="https://github.com/techXgood/techXgood">TechXgood repository</a>.</li><li><strong>Website rebuild via GitHub Pages:</strong> This commit triggers GitHub Pages to rebuild the static TechXgood website, ensuring the showcase is always up-to-date with the latest curated projects.</li></ol><h3>Why this tech stack matters for the TechXgood GitHub project</h3><p>This Python-driven, GitHub Actions-automated approach is fundamental to the <a href="https://github.com/techXgood/techXgood">TechXgood open source initiative</a>:</p><ul><li><strong>Automation:</strong> minimizes manual effort in discovering philanthropic software.</li><li><strong>Cost-efficiency:</strong> operates entirely within GitHub’s free an_COSTS_TIERs, perfect for a non-profit, open-source project.</li><li><strong>Transparency:</strong> the entire discovery and curation logic is open for review and contribution on the <a href="https://github.com/techXgood/techXgood">TechXgood GitHub repository</a>.</li><li><strong>Scalable curation:</strong> enables sifting through numerous open-source projects to find those with a true “tech for good” focus.</li></ul><h3>Explore the code and contribute to TechXgood</h3><p>The crawler.py script and the overall architecture of TechXgood offer a prime example of leveraging GitHub&#39;s ecosystem to build impactful, cost-effective platforms. We encourage developers and tech enthusiasts to dive into the <a href="https://github.com/techXgood/techXgood">TechXgood GitHub repository at </a><a href="https://github.com/techXgood/techXgood">https://github.com/techXgood/techXgood</a>.</p><p>By exploring the Python code, the data models, and the GitHub Actions workflows, you can gain deeper insights into this innovative approach to highlighting philanthropic open source projects. Contributions, suggestions, and the sharing of other “tech for good” projects are always welcome.</p><p>Visit the <a href="https://techxgood.github.io/techxgood/">TechXgood website</a> to see the results of this automated pipeline and discover amazing open source projects making a difference.</p><p><em>What are your thoughts on the TechXgood project’s technical approach to discovering philanthropic open-source software? Explore the </em><a href="https://github.com/techXgood/techXgood"><em>TechXgood GitHub repository</em></a><em> and share your feedback!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2afab15bd7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TechXgood: when open source technology meets philanthropy (and it all runs on GitHub!)]]></title>
            <link>https://medium.com/@leviathan36/techxgood-when-open-source-technology-meets-philanthropy-and-it-all-runs-on-github-c2abc5f0cb30?source=rss-9986e6a57d4------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2abc5f0cb30</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[environment]]></category>
            <category><![CDATA[philanthropy]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python3]]></category>
            <dc:creator><![CDATA[Cristian]]></dc:creator>
            <pubDate>Sat, 10 May 2025 10:56:41 GMT</pubDate>
            <atom:updated>2025-05-10T10:56:41.567Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Imagine a place where genius meets generosity. This is TechXgood.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oaOiUTjgdNluepJElGfnBQ.jpeg" /><figcaption>Clear Bulb Planter On The Gray Rock by <a href="https://www.pexels.com/it-it/@singkham-178541/">Singkham</a></figcaption></figure><p>In the vast universe of software, there are projects that don’t aim for profit, but to make a difference. Brilliant ideas, born to solve real problems, help communities, or simply make the world a slightly better place. Often, these gems remain hidden, known only to a small circle of insiders.</p><p>And this is where <a href="https://techxgood.github.io/techxgood/"><strong>TechXgood</strong></a> comes in:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7VIZ-oePANtIcrL3ghzWUw.png" /><figcaption><a href="https://techxgood.github.io/techxgood/">https://techxgood.github.io/techxgood/</a></figcaption></figure><h3>What is TechXgood and why should you care?</h3><p>TechXgood isn’t just a website; it’s a showcase for ingenuity at the service of the common good. Its mission is simple yet powerful: <strong>to discover, highlight, and promote open-source IT projects that have a positive impact and philanthropic goals.</strong></p><p>Think of it as a beacon shining a light on those technological solutions created not for gain, but to help others. Projects that anyone can use, modify, and distribute freely, thereby amplifying their beneficial reach.</p><p>If you’re a developer, a tech enthusiast, or simply someone curious about how innovation can be used for noble purposes, <strong>TechXgood</strong> is a resource worth exploring.</p><h3>The genius is also in the infrastructure: zero costs, maximum efficiency</h3><p>One of the most fascinating features of <strong>TechXgood</strong>, beyond the projects it hosts, is its very nature. The entire site is built and maintained <strong>without any traditional hosting or backend costs.</strong></p><p>How is this possible? By leveraging the power and flexibility of the GitHub ecosystem:</p><ul><li><strong>GitHub Pages</strong> for hosting the static site.</li><li><strong>GitHub Actions</strong> for any “backend logic” or necessary automation, such as updating content or managing project data.</li></ul><p>This approach not only demonstrates an intelligent use of freely available resources but also perfectly aligns with the project’s open-source philosophy: transparency, accessibility, and sustainability. It’s proof that with the right ideas and tools, significant platforms can be created without needing large budgets.</p><p>The <a href="https://github.com/techXgood/techXgood">repository</a> itself is, of course, open and accessible to everyone:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mOVm2y7ti2F-5fEaU0L9Ew.png" /><figcaption><a href="https://github.com/techXgood/techXgood">https://github.com/techXgood/techXgood</a></figcaption></figure><h3>The core idea: a virtuous cycle of inspiration and utility</h3><p>The primary goal of TechXgood is twofold:</p><ol><li><strong>Provide visibility:</strong> Offer a platform to deserving open-source projects that might otherwise go unnoticed.</li><li><strong>Inspire:</strong> Show what’s possible when a passion for technology combines with a desire to contribute positively to society.</li></ol><p>By visiting TechXgood, you might discover:</p><ul><li>Software tools that help non-profit organizations.</li><li>Applications that facilitate access to information or education.</li><li>Projects that address social or environmental issues through technology.</li><li>Libraries and frameworks that, while technical, are fundamental for building other “for good” applications.</li></ul><p>And the beauty is that every featured project is open source, meaning you can not only use it but also study it, contribute to its development, or draw inspiration from it to create something of your own that’s equally useful.</p><h3>Join the cause (even if just with a visit!)</h3><p><strong>TechXgood</strong> is a young project but with great potential. Its success and ability to make a difference also depend on the community that forms around it.</p><p><strong>What can you do?</strong></p><ul><li><strong>Visit the site:</strong> <a href="https://techxgood.github.io/techxgood/">https://techxgood.github.io/techxgood/</a> explore the projects, get inspired.</li><li><strong>Follow the repository on GitHub:</strong> <a href="https://github.com/techXgood/techXgood">https://github.com/techXgood/techXgood</a> you can see how it’s built, suggest improvements, or, why not, contribute.</li><li><strong>Share:</strong> If you know someone who might be interested in these topics, or if you find a particularly enlightening project, talk about it! Spreading the word is crucial for open-source initiatives.</li><li><strong>Suggest projects:</strong> If you know of open-source projects with philanthropic aims that deserve to be on <strong>TechXgood</strong>, don’t hesitate to mention them through the GitHub repository channels.</li></ul><p>In an increasingly digitized world, initiatives like <strong>TechXgood</strong> remind us that technology can and must be a force for good. Let’s support them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2abc5f0cb30" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>