DEV Community: Alexandre Bento Freire

Why is PHP losing popularity?

Alexandre Bento Freire — Tue, 21 Jan 2025 21:28:41 +0000

If you compare the user base of PHP with languages like Python or JavaScript on platforms like LinkedIn or Reddit, the difference is striking. PHP's position on the TIOBE Index has dropped from 7th to 13th.

Is PHP dead? No, but its trajectory is concerning. While languages like Python and JavaScript continue to attract developers, PHP struggles to shake off its limitations and old perceptions.

For years, PHP was closely associated with WordPress, which many developers dismissed as "not real programming." Those days are largely over. PHP has evolved with new versions, and frameworks like Laravel and Symfony have made the language more elegant and powerful. Yet, developers continue to migrate elsewhere.

Why?

PHP’s core design still suffers from early decisions made to solve simple backend tasks. Unlike JavaScript, which learned from its past and grew substantially, PHP retains significant inconsistencies, acting as a drag on its growth.

Examples:

PHP's function names and argument orders are notoriously inconsistent.
Arrays default to hash keys, introducing inconsistencies in functions like array_merge. Workarounds like SplFixedArray exist, but shouldn’t be necessary.
Even something as simple as using preg_replace with a regex often fails in PHP, while the same works flawlessly in Python.

These issues are compounded by PHP’s reliance on frameworks to mask its flaws, whereas Python and JavaScript focus on core language improvements.

Even Facebook, now Meta, created Hack to address PHP’s shortcomings. However, it never gained mainstream traction.

I’ve worked with PHP since its early days and still maintain Laravel projects today. However, many of us stay with PHP out of necessity rather than choice—it’s often too costly to migrate existing codebases.

If PHP wants to remain relevant, it must listen to its users, assess its shortcomings, and evolve. Otherwise, it risks becoming another COBOL: alive but primarily for maintaining legacy systems.

What are your thoughts on PHP’s future?

Linux Mint 22.1

Alexandre Bento Freire — Fri, 17 Jan 2025 21:20:03 +0000

The Linux Mint team has recently released version 22.1, initially as an ISO and now also available via the Update Manager.

I'm a die-hard fan of Linux Mint Cinnamon and have no plans to switch to another distro or OS.

While many changes in this release are under the hood, the team has made significant progress toward fully supporting Wayland. This version also transitioned to Aptkit and Captain, replacing outdated packages.

Visually, you’ll notice rounder dialogs and a new Night Light applet to reduce screen temperature and ease eyestrain. Another highlight is the addition of shortcuts to Nemo actions, a feature I’ve been anticipating for years, as I frequently use these actions to transform images and documents.

Finally, Bulky now supports removing accents from filenames. While I don’t use Bulky, I rely on my own bulk file renaming tool, RenameToIX, which will also include this feature in the near future.

What do you think of the latest Linux Mint update?

What does it mean to be sentient, conscious, or self-aware?

Alexandre Bento Freire — Mon, 13 Jan 2025 17:11:05 +0000

In the "Terminator" franchise, Skynet becomes self-aware at 2:14 a.m., EDT, on August 29, 1997. This has been a recurring theme in pop culture, where these three distinct concepts are often used interchangeably. With the rise of generative AI and the hype surrounding AGI (Artificial General Intelligence), these ideas have become central in discussions about artificial intelligence.

Sentience refers to the capacity to perceive or feel sensations, such as pain or pleasure. Being sentient does not necessarily mean being conscious of these sensations; it simply implies the ability to experience them. Consciousness, on the other hand, is the state of being aware of and able to think about one’s existence, surroundings, and mental states. Humans and some advanced animals share this capability. A step further is self-awareness, where an entity not only recognizes its existence but also identifies itself as distinct from others—like recognizing oneself in a mirror.

Many philosophers and scientists have shaped our understanding of these concepts. René Descartes, John Locke, and the Portuguese neuroscientist Antonio Damasio have made significant contributions to this field. Damasio, in particular, has advanced the neuroscientific exploration of how consciousness arises from the interaction between the brain and body.

The question of whether AGI can become sentient remains a topic of intense debate. While current AI systems simulate aspects of cognition, whether they can genuinely feel, be aware, or recognize themselves as distinct entities is a profound and unresolved challenge.

Do you know what RISC is, what about CISC, and why does it matter?

Alexandre Bento Freire — Sun, 05 Jan 2025 12:35:45 +0000

Do you know what RISC is, what about CISC, and why does it matter?

The battle between RISC (Reduced Instruction Set Computing) and CISC (Complex Instruction Set Computing) has shaped the history of computing, yet many may not fully grasp their significance in modern technology. Let’s look the evolution of these architectures, their differences, and why this distinction still matters.

The origins of RISC date back to the early 1980s, yet for decades, CISC processors dominated the market. CISC processors, such as those used in the first IBM PCs, were designed with a broad set of instructions, making them capable of performing complex tasks in fewer lines of code. However, as computing power increased, the inefficiencies of CISC processors became apparent.

In contrast, RISC processors, designed with a smaller set of simple instructions, allowed for faster execution and lower power consumption. Because their instruction sets are smaller, the internal circuitry of RISC CPUs is simpler, meaning instructions can be executed more quickly and efficiently.

The story begins in the 1960s, when computers were slower and memory was limited. At that time, it made sense for CPUs to have complex instructions to reduce the number of lines of code, a necessity for efficient programming with limited resources. However, as computing power and memory capacity increased in the following decades, the need for these complex instructions began to diminish.

In 1974, Intel introduced the Intel 8080 processor, which later became the foundation for the Intel 8088 used in the IBM PC. This marked the beginning of the consumer desktop PC revolution. At the same time, the CISC architecture continued to dominate, with its emphasis on rich instruction sets, which helped simplify programming.

In the early 1980s, UC Berkeley, funded by DARPA (the agency that also funded the development of the Internet), developed the first RISC processor, a design that was simpler, faster, and more efficient than anything before it. The RISC approach gained traction in academic and research circles, but its adoption in consumer computing was slower due to the vast amount of existing code written for CISC processors.

By the 1990s, as computers became faster and memory became more abundant, the appeal of RISC grew. However, transitioning existing systems to RISC meant rewriting massive amounts of software, making the change cost-prohibitive. It wasn’t until the rise of smartphones in the 2000s that RISC processors, particularly the ARM architecture, became widespread. Companies like Qualcomm and Samsung popularized ARM processors, making them the foundation of mobile computing.

Apple’s journey through RISC and CISC architectures has been an interesting one. From 1994 to 2006, Apple used PowerPC processors, which were based on RISC. This was a period when Steve Jobs and Apple embraced RISC for its performance benefits and efficiency. However, in 2006, Apple transitioned to Intel-based CISC processors, which enabled better compatibility with software and improved performance. The shift helped Apple grow into the dominant force it is today.

But Apple’s story doesn’t end there. With the advent of its M-series chips, starting with the M1 in 2020, Apple returned to RISC, this time leveraging ARM-based architecture for its MacBook, iMac, and Mac mini. The transition allowed Apple to further improve performance while maximizing battery life—a key advantage in mobile devices that has now extended to laptops.

In conclusion, while CISC processors once dominated, the advent of RISC has proven to be essential in the evolution of mobile and laptop computing. Today, we continue to see the benefits of RISC architecture, particularly in power efficiency and performance for devices like smartphones and laptops. The choice between RISC and CISC is not just a technical debate but one that defines the usability, efficiency, and longevity of modern computing devices.

Ternary Conditional Operators

Alexandre Bento Freire — Tue, 26 Nov 2024 11:31:39 +0000

Python is one of the few popular modern languages that doesn't follow the traditional C-style syntax for ternary conditional operators. Instead of the standard format where the condition is followed by the true expression and then the false expression, Python places the true expression first, followed by the condition and the false expression.

However, not every language supports ternary conditional operators. For example, Go, a rapidly growing language in popularity, does not have a ternary operator. This absence reflects Go's design philosophy, which prefers simplicity and avoids operators that might reduce code readability.

The table below summarizes how different programming languages and language-like systems (such as SQL and Excel) handle ternary conditional operators or their equivalents.

In the age of AI, sharpen your skills

Alexandre Bento Freire — Tue, 19 Nov 2024 13:12:00 +0000

I've noticed many people who are deeply afraid of AI taking their jobs and rendering them obsolete. Meanwhile, others use tools like ChatGPT for content creation, relying solely on copy and paste.

Remember these key points:

The world is always evolving—AI is not the first challenge.

Consider how the COVID-19 pandemic forced people around the globe to stay home. Yet, we adapted, rebuilt, and continued forward. Change is constant, and resilience ensures we remain standing.
Hard times make us stronger.

Prosperity may bring comfort, but it’s the challenges that push us to grow. In those moments of struggle, we adapt, overcome, and come out better on the other side.
Master technology—don’t let it master you.

Tools like ChatGPT, navigation apps, and social media can enhance your life and work, but they should not define you. Learn to thrive without them.

Learn to code like an expert, navigate without maps, and communicate effectively. The habit of continuous learning is your greatest strength.
Learn to Speak.

Beyond technical skills, the ability to articulate your ideas clearly is vital. In job interviews or professional settings, how you deliver your message matters just as much as what you know. Avoid abbreviations, slang, or hesitation. Speak with clarity and confidence.
Promotions favor team players.

Technical expertise is essential, but promotions often go to those who collaborate effectively and understand company goals. Learn to socialize, build trust, and work as part of a team. Being approachable and cooperative can open doors that technical skills alone cannot.

This message was written by Alexandre Bento Freire and fine-tuned with the help of ChatGPT.

ABeamer - Frame-by-Frame Web Animation Framework

Alexandre Bento Freire — Wed, 30 Oct 2024 13:30:15 +0000

For web developers and animators seeking an alternative to traditional CSS animations, ABeamer offers a distinct approach with its frame-by-frame animation capabilities. Unlike CSS animations that typically respond to user interactions, ABeamer harnesses web technology with a unique frame-based engine, designed to operate independently of user actions. With ABeamer, each frame is rendered precisely at a defined frames-per-second rate, enabling seamless server-side rendering of animations into animated GIFs or video clips.

Links:

Github: https://github.com/a-bentofreire/abeamer
Website: https://abeamer.devtoix.com/
In Action: https://codepen.io/a-bentofreire
Animated Charts Example: https://codepen.io/a-bentofreire/pen/mKjQXR
Gallery: https://abeamer.devtoix.com/#gallery

ABeamer Key Features:

Built in TypeScript: ABeamer’s core is developed in TypeScript, providing both structure and flexibility for TypeScript and JavaScript developers.
Extensibility and Plugins: ABeamer is engineered with extensibility in mind and comes equipped with several plugins, including options for charting, transitions and oscillation effects. These tools allow developers to integrate a wide array of visual elements with customizability at each step.
Easing Functions: Supporting various easing options, ABeamer provides smooth transitions and complex movement patterns, adding a refined, professional touch to animations.
Comprehensive Documentation: Detailed documentation ensures that developers can navigate ABeamer’s capabilities with ease, from the basics to advanced configurations.
Gallery of Examples: ABeamer includes a broad selection of examples, showcasing its versatility and range for anyone exploring its potential.

For developers who need precise control and media-ready outputs, ABeamer is a flexible and capable solution, setting itself apart by allowing frame-by-frame generation. This level of control supports a wide range of animation needs, from web-based sequences to professionally exported clips. With a solid TypeScript foundation, rich extensibility, and an extensive gallery of examples, ABeamer is a powerful tool for creating dynamic animations that meet both web and multimedia requirements.

PyTraceToIX - How to debug Jinja2 templates, Flask web apps without breaking the design or code changes

Alexandre Bento Freire — Thu, 17 Oct 2024 22:29:54 +0000

PyTraceToIX is an expression tracer designed for debugging Jinja2 templates, Flask web apps, lambdas, list comprehensions, method chaining, and expressions in general.

Code editors often cannot set breakpoints within these kinds of expressions, which requires significant code modifications to debug effectively.

For Jinja2 templates, the debug extension can be used, but it typically dumps the entire context, making it difficult to isolate specific issues. PyTraceToIX solves this by allowing developers to trace and write specific data directly to sys.stdout or a stream without altering the design or making any changes to the web application.

Additionally, PyTraceToIX can capture multiple inputs and their results, displaying them all in a single line, making it easier to view aggregated data and trace the flow of values.

PyTraceToIX offers a straightforward solution to these challenges, simplifying debugging while preserving the integrity of the original codebase.

It was designed to be simple, with easily identifiable functions that can be removed once the bug is found.

PyTraceToIX has 2 major functions:

c__ capture the input of an expression input. ex: c__(x)
d__ display the result of an expression and all the captured inputs. ex: d__(c__(x) + c__(y))

And 2 optional functions:

init__ initializes display format, output stream and multithreading.
t__ defines a name for the current thread.

Installation

pip install pytracetoix

Jinja2 templates Usage

In this example:

A flask web app uses a Jinja2 template
It generates a shopping card html table with product, quantity and final price

Product	Qty	Final Price
Smartphone	5	2500
Wireless B	50	49960
Smartphone	20	1990

The product name is only the first 11 characters, but we need to know the full name.
It only shows the final price which is Price * Qty - discount.
The discount is dependent of the quantity.
c__ captures the complete name but doesn't change the design.
c__ captures the qty and labels it as Qty.
c__ captures the discount value.
d__ outputs to sys.stdout all the captured inputs and the final price.

The stdout will display these lines:

i0:`Smartphone 128GB` | qty:`5` | i2:`500` | discount:`0` | _:`2500`
i0:`Wireless Bluetooth Headphones` | qty:`50` | i2:`1000` | discount:`40` | _:`49960`
i0:`Smartphone 64GB Black` | qty:`20` | i2:`100` | discount:`10` | _:`1990`

Jinja2 template:

<html lang="en">
<head><link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/css/bootstrap.min.css" rel="stylesheet"></head>
<body>
    <div class="container mt-5">
        <h1>Shopping Cart</h1>
        <table class="table table-striped">
            <tr><th>Product</th><th>Qty</th><th>Final Price</th></tr>
            {% for item in purchases %}
            {% set product = products[item['product']] %}
            <tr>
                <td>{{ c__(product['name'])[0:10] }}</td>
                <td>{{ c__(item['qty'], name='qty') }}</td>
                <td>{{ d__(c__(product['price']) * item['qty']
                    - c__(discount(item['qty']), name='discount')) }}</td>
            </tr>
            {% endfor %}
        </table>
    </div>
</body>
</html>

app.py:

from flask import Flask, render_template
from pytracetoix import c__, d__

app = Flask(__name__)

app.Jinja2_env.globals['d__'] = d__
app.Jinja2_env.globals['c__'] = c__

DISCOUNTS = {50: 40, 20: 10, 10: 5, 0: 0}
PRODUCTS = {
    'WB50CC': {'name': 'Wireless Bluetooth Headphones', 'price': 1000},
    'PH20XX': {'name': 'Smartphone 128GB', 'price': 500},
    'PH50YY': {'name': 'Smartphone 64GB Black', 'price': 100}
}

PURCHASES = [
    {'product': 'PH20XX', 'qty': 5},
    {'product': 'WB50CC', 'qty': 50},
    {'product': 'PH50YY', 'qty': 20}
]


def discount(qty): return next((k, v) for k, v in DISCOUNTS.items() if k <= qty)[1]


@app.route('/', methods=['GET'])
def index():
    return render_template('index.html', products=PRODUCTS, purchases=PURCHASES, discount=discount)


if __name__ == '__main__':
    app.run(debug=True)

If the previous example, we add c__ to the discount function on app.py:

def discount(qty): return c__(next((k, v) for k, v in DISCOUNTS.items() if k <= qty))[1]

It will add richer discount information to the output:

i0:`Smartphone 128GB` | qty:`5` | i2:`500` | i3:`(0, 0)` | discount:`0` | _:`2500`
i0:`Wireless Bluetooth Headphones` | qty:`50` | i2:`1000` | i3:`(50, 40)` | discount:`40` | _:`49960`
i0:`Smartphone 64GB Black` | qty:`20` | i2:`100` | i3:`(20, 10)` | discount:`10` | _:`1990`

JsTraceToIX - Debugging React, Vue, and Node.js just got easier! – no need to clutter your codebase with `console.log`!

Alexandre Bento Freire — Wed, 16 Oct 2024 18:49:00 +0000

If you've ever had to debug React or Vue components, arrow functions, or complex expressions on Node or the Web Browser, you know the pain of adding multiple console.log statements and making unnecessary code changes. That's where JsTraceToIX comes in!

Project Link

Key Features:

Simplifies debugging with minimal code changes.
Supports debugging of React, Vue, and Node.js environments, as well as regular browsers.
Handles single-line expressions and arrow functions with ease.
Easily define names, filter results, and override inputs and outputs for better traceability.
Simple function names, like c__ and d__, make it easy to spot and remove traces after catching the bug.
Works seamlessly with multithreaded environments.

Bonus: If you're working with Python, check out PyTraceToIX, which offers the same powerful debugging tools for your Python projects.

Say goodbye to complex and messy debugging – with JsTraceToIX, you can capture inputs and display results all in one step, making debugging cleaner and faster!

Check out JsTraceToIX and see how it can simplify your debugging process.

Installation

Environment	Require Installation
Browser	No
Node.js	Yes
React	Optional
Vue	Yes

npm install jstracetoix --save-dev

React Usage

In this example:

cityTax arrow function captures the input price and names it 'Price'.
On ShoppingList function:
- c__ captures the title in the first <td>.
- c__ captures the output of the cityTax and names it CityTax in the 2nd <td>.
- d__ displays the aggregated information in a single line: title, price, cityTax, total Price.

The d__ will generate this output:

i0:`Rice` | Price:`10` | CityTax:`5` | _:`15`
i0:`Coffee` | Price:`30` | CityTax:`15` | _:`45`
i0:`Shoes` | Price:`100` | CityTax:`15` | _:`115`

import './App.css';
// Without local installation
import { c__, d__ } from 'https://cdn.jsdelivr.net/gh/a-bentofreire/jstracetoix@1.1.0/component/jstracetoix.mjs';

// If it's installed locally via "npm install jstracetoix --save-dev"
// import { c__, d__ } from 'jstracetoix/component/jstracetoix.mjs';

const cityTax = (price) => c__(price, {name: 'Price'}) > 20 ? 15 : 5;
const products = [
    { title: 'Rice', price: 10, id: 1 },
    { title: 'Coffee', price: 30, id: 2 },
    { title: 'Shoes', price: 100, id: 3 },
];

function ShoppingList() {
    const listItems = products.map(product =>
        <tr key={product.id}>
            <td>{c__(product.title)}</td>
            <td>{d__(product.price + c__(cityTax(product.price), { name: 'CityTax' }))}</td>
        </tr>
    );

    return (
        <table><tbody>{listItems}</tbody></table>
    );
}

function App() {
    return (
        <div className="App">
            <header className="App-header">
                <ShoppingList />
            </header>
        </div>
    );
}

export default App;

Node.js Usage

In this example:

c__.allow() - overrides the input value being debugged when value > 40.00, for other values it doesn't captures the input.
d__.allow() - overrides the result value being debugged.
d__.after() - stops the program after displaying the result and the captured fields.

import { c__, d__ } from 'jstracetoix';

const products = [
    { "name": "Smartphone 128GB", "price": 699.00 },
    { "name": "Coffee Maker", "price": 49.99 },
    { "name": "Electric Toothbrush", "price": 39.95 },
    { "name": "4K Ultra HD TV", "price": 999.99 },
    { "name": "Gaming Laptop", "price": 1299.00 }];

const factor = (price) => price < 1000 ? 1.10 : 1;

const prices = d__(products.map(product => c__(product.price,
    {
        allow: (index, name, value) => value > 40.00 ?
            Math.floor(value * factor(value)) : false,
        name: product.name.substring(0, 10)
    })), {
    allow: (data) => data._.map((v, i) => `${i}:${v}`),
    after: (data) => process.exit() // exits after displaying the results
});
// Smartphone:`768` | Coffee Mak:`54` | 4K Ultra H:`1099` | Gaming Lap:`1299` | _:`["0:699","1:49.99","2:39.95","3:999.99","4:1299"]`

// this code is unreachable
for (const price in prices) {
    let value = price;
}

Output

Environment	Default Output Function
Browser	console.debug
Node.js	process.stdout
React	console.debug
Vue	console.debug

Except for Node.js environment, the output is displayed in the browser's developer tools under the "Console Tab".
Since the output is generated using console.debug, it can easily be filtered out from regular console.log messages.

The default output function can be override using init__({'stream': new_stream.log })

Metadata

The d__ function callbacks allow, before and after will receive a parameter data with the allowed inputs plus the following meta items:

meta__: list of meta keys including the name key.
thread_id__: thread_id being executed
allow_input_count__: total number of inputs that are allowed.
input_count__: total number of inputs being captured.
allow__: If false it was allowed. Use this for after callback.
output__: Text passed to before without new_line.
name: name parameter

Documentation

Package Documentation

How to start python or ipython with packages pre-imported.

Alexandre Bento Freire — Wed, 21 Aug 2024 20:36:48 +0000

Instead of every time you execute python or ipython, have to write "import os" or other common packages, this script will start python with these packages imported

#!/usr/bin/env bash
# -------------------------------------------------------------
#  Calls ipython or python3 with multiple packages imported
# -------------------------------------------------------------

if [[ -z "$1" ]] || [[ -f "$1" ]]; then
    [[ -n "$(command -v ipython3)" ]] && EXEC="ipython3" || EXEC=python3
    TMP_PY=/$TMPDIR/$EXEC.py
    printf "import os, re, sys, math, datetime, yaml\n" >$TMP_PY
    $EXEC -i $TMP_PY "$@"
else
    python3 "$@"
fi