DEV Community: Trishan Fernando

GitPulse: GitHub Trending Tool

Trishan Fernando — Tue, 23 Dec 2025 11:41:13 +0000

Learning-by-Building

Focus Built a GitHub “Trending” CLI in Python — not to solve a big problem, but to learn how real CLI tools feel, ship, and scale.

Comet Browser : Perplexity’s Thinking Browser

Trishan Fernando — Wed, 08 Oct 2025 15:48:30 +0000

We’ve all been living in browsers for years now — Chrome, Edge, Safari… they all kinda feel the same. Open tabs, search things, maybe add a couple of extensions, repeat. Useful? Sure. Fun? Not so much.

And then Comet from Perplexity. And honestly, it doesn’t just feel like another browser — it feels like a new class. It’s as if having an AI buddy floating right amidst your browsing life.

Get Early Access & Download Comet

Comet is not available for free it needs the 200$ Perplexity Subscription with an invitation. But you can get it through partners for free if you are a university Student.

Get Early Access With Your University Email.Use your University email to Verify that you are a student

Get Early Access & Download Comet

What’s the excitement about?

Comet isn’t all about “opening sites faster.” It’s about doing things with your browser instead of just staring at it.

Got 10 tabs open doing research? Tell Comet to summarize them into one neat note.

Shopping for a laptop? Have it search deals on websites and show you the top
choices.

Writing an email? Cross out a couple of pages and voila — it writes something that even sounds logical.

Doing a project? Keep your tabs + notes + AI summaries all bundled up in a neat space you can return to.

It is like the distinction between you driving a vehicle and having a vehicle that helps you drive, monitors your schedule, and maybe even helps you save money on fuel in the bargain.

What people are saying

I’ve been skimming through Reddit, X, and LinkedIn, and the vibe is clear: folks are hyped. People call it “futuristic,” “the only browser that actually boosts productivity,” and “perfect for research.” Students, writers, and even devs juggling docs love that it cuts down tab chaos.

Of course, there’s a catch — some grumblings that it’s invite-only for certain plans, and pricing debates. Totally fair. But that’s what you get when you’re not building another browser, you’re trying to rethink how we browse period.

One heads-up though ???

AI browsers are new territory. Security researchers raise the alarms for dangers like nefarious sites trying to trick the AI into making bad decisions (autofilling data, risky clicks, etc.). So yeah — Comet does have a future vibe to it, but maybe don’t fling your banking login data at it just yet.

Why I think this matters

Comet is the first browser I’ve used that truly seems to be built for the way we actually work in 2025: multitasking, info overload, constant context-switching. Instead of just allowing us to have more tabs, it processes them.

And for real? Once you get a taste of it, browsing with a “regular” browser again feels… kinda like using a Nokia brick phone once you’ve had a smartphone.

And Comet is only given access to their partners only and this need to pay 200$(Perplexity Pro) If you are an university student , you can get the early access from the below invitation link for 100% Free.

Get Early Access to download Comet

Stay Tuned with me to more updated Stuff in technology !

Adding Field Attributes to multiple fields at once in Odoo

Trishan Fernando — Wed, 02 Apr 2025 18:54:19 +0000

When developing in Odoo, you might encounter situations where you need to add the same attribute to multiple fields. For instance, imagine you have a model with 20–30 fields and later decide to enable tracking on all of them. Adding the tracking attribute manually to each field definition would be time-consuming and potentially error-prone.

This article explores how to leverage Odoo’s fields_get() method to identify fields and modify their attributes programmatically, saving significant development time.

Understanding fields_get()
Odoo provides a built-in method called fields_get() that returns all fields and their attributes for a specific model. This method has two optional arguments: field name and field attributes.

Example Usage
Here’s a simple example of how to use fields_get() to view all fields and their attributes in a model:

When executed, this function will output something like:

Practical Use Case: Adding Tracking to Multiple Fields
Let’s look at a practical scenario where this approach is particularly useful. Imagine you’ve created a model with numerous fields, and after development, you decide that all fields should be tracked for audit purposes. Instead of modifying each field definition individually, you can use the following function:

def add_attribute(self):
    model_obj = self.env['your.model.name']
    fields = model_obj.fields_get()
    print(type(fields))

    for field_name, field_attrs in fields.items():

        # Get the field object from the model's _fields dictionary
        field_obj = model_obj._fields.get(field_name)

        if field_obj:

            # Check if tracking attribute is not already set or is False
            if not getattr(field_obj, 'tracking', False):

                # Skip fields that cannot be tracked
                if field_obj.type == 'one2many' or (field_obj.compute and not field_obj.store):
                    print(f"Field {field_name} cannot be tracked (one2many or computed non-stored).")
                    continue

                # Set tracking attribute to True
                field_obj.tracking = True
                print(f"Field {field_name} is now tracked.")
            else:
                print(f"Field {field_name} is already tracked.")
        else:
            print(f"Field {field_name} not found in model.")

This function iterates through all fields in the specified model and sets the tracking attribute to True for eligible fields. It also includes validation to skip fields that cannot be tracked (like one2many fields or computed non-stored fields).

Beyond Tracking: Additional Applications
While our example focuses on adding tracking, this technique can be applied to modify any field attribute programmatically. Some other potential uses include:

Adding specific groups to field access rights
Modifying string attributes for internationalization
Changing widget attributes for better UI display
Setting default values across multiple fields

Important Considerations
When using this approach, keep these points in mind:

Environment Impact: This modification happens at runtime and may not persist after server restart unless you’re modifying the actual field definitions in the Python code.
Production Caution: Be careful when applying this in production environments, as modifying field attributes can have system-wide effects.
Performance: For very large models, iterating through all fields could impact performance.

Conclusion
This approach provides an alternative method for modifying field attributes in Odoo models with multiple fields. While direct field definition remains the standard practice for most development scenarios, understanding how to programmatically modify attributes can be useful in specific situations where bulk changes are needed.

The technique leverages Odoo’s built-in functionality to access field definitions, offering a way to make consistent changes across many fields without manual intervention.

Stay Tuned !

OWL JS 01 — Why Odoo Created OWL: A Framework Built for Modularity

Trishan Fernando — Mon, 31 Mar 2025 20:25:56 +0000

In the JavaScript ecosystem filled with established frameworks like React and Vue, Odoo's decision to create their own framework—OWL (Odoo Web Library)—might seem counterintuitive. After all, why reinvent the wheel? This article explores the key reasons behind this strategic choice and highlights what makes OWL uniquely suited for Odoo's specific needs.

The Core Challenge: Extreme Modularity

At the heart of Odoo's decision lies one fundamental characteristic: Odoo is extremely modular. This means:

Core components don't know beforehand what files will be loaded or executed
The UI state is determined entirely at runtime
Standard build toolchains aren't viable
Odoo isn't just an application with a UI; it's an application that generates a dynamic UI

This modularity creates unique requirements that most established frameworks aren't designed to address.

Key Considerations Behind Creating OWL

1. Technical Independence
Odoo needed to maintain control over their technology stack without depending on decisions made by large companies like Facebook (React) or Google. If these companies changed their licensing or technical direction, it could create significant problems for Odoo's specialized needs.

2. Class Components
While modern frameworks are moving away from class components toward functional approaches, Odoo specifically benefits from class-based architecture:

Inheritance provides an effective way to share code between generic components
Each class method serves as an extension point for addons
Components can be monkey-patched to add behavior from outside

3. JIT Template Compilation
Odoo's dynamic nature requires just-in-time compilation:

Templates are stored as XML in a database and customized via XPaths
Templates need to be fetched and compiled at the last possible moment
The system must be able to generate and compile templates at runtime

4. Minimal Tooling Requirements
OWL is designed to work with minimal mandatory tooling:

Templates are compiled by the browser using built-in XML parsers
Components can be written with template strings
The framework can be integrated with a simple <script> tag
No complex build pipeline is required on production servers

5. XML-Based Templates
Odoo stores templates as XML documents, allowing for powerful customization through XPaths. This feature is central to Odoo's modularity but isn't well-supported by other frameworks.

6. Simplified Developer Experience
OWL prioritizes straightforward APIs:

Uses familiar class-based components
Features an explicit reactivity system
Implements clear scoping rules
Avoids unnecessary complexity

7. Optional Reactivity and Concurrency
OWL offers:

A reactive system that can be optionally disabled when not needed
A powerful yet simple concurrent mode for managing asynchronous state changes

Conclusion

Creating OWL wasn't a decision Odoo made lightly. While established frameworks excel in their designed contexts, Odoo's unique requirements demanded something different. OWL represents a framework built specifically for extreme modularity, just-in-time compilation, and developer accessibility—making it the right tool for Odoo's specialized ecosystem.

Stay Tuned for more articles...