Undefined.

Audiophile | Coder | Lurker

[Undefined. @Lakshyaing]

@volklub Rejected new Amaze in favour Kylaq last year. Both were released at the same time.

Duringtest drive, the interiors in Kylaq Sig+ felt more premium than Amaze’s top end.
Genuinely wanted to book the Amaze, but something really felt amiss, while Kylaq made us smile all the way

[Juri Strumpflohner @juristr]

POV: Senior Agentic Engineer

[Abhishek Singh @0xlelouch_]

Most people optimize their entire career for guarantees:
9–5 job → fixed salary → predictable increments → “safe” tech → minimal risk.
And yes, it works. You get exactly what you signed up for.

But the biggest upside in tech doesn't comes from guaranteed paths.

The engineers who make outsized progress are the ones willing to accept temporary drawdowns:
– switching stacks before they’re “hot”
– joining a startup with uncertainty
– taking ownership of systems they might break
– publishing opinions and code publicly
– betting on skills before the market rewards them

Normie tech careers are obsessed with never looking bad: never failing an interview, never joining a risky team, never learning something that might not pay off.

So they overpay for safety - in time, upside, and agency.

Yes, you might lose short-term comfort by taking risks. But playing only for certainty guarantees one thing: you cap your ceiling before you even start.

The goal here is asymmetric risk - situations where downside is survivable, but upside is life-changing.

In tech, avoiding all drawdowns doesn’t make you safe. It just quietly removes your chance to win big.

[Ankush Dharkar wants you on tier3.college @ankushdharkar]

❓How can I learn/upskill/prepare with a fulltime job?
An "excuse" I hear often.

Do you have a goal? (Getting that better paying job, switching fields, learning DSA etc?)

If no, then learning is a hobby. Do it passively (but hopefully often enough)

If YES, read on

[Ivan Zhao @ivanhzhao]

https://t.co/fxHYR6S29D

[Akhilesh Mishra @livingdevops]

As a DevOps engineer, we all use Nginx.
But most don’t understand how powerful Nginx really is.

Here’s what happens when a request hits your Nginx server:

Nginx sits as your system’s entry point, listening on ports 80 and 443. When a request comes in, it instantly decides the best action based on your configuration.

- For static files like images or CSS, Nginx serves them directly from disk. Blazing fast with no backend needed.

- For dynamic requests, it acts as a reverse proxy. It forwards requests to your backend applications and waits for responses.

👉But here’s where it gets powerful:

- Load balancing across multiple backend servers with different strategies.
- TLS termination handling all SSL certificates and encryption.
- Response caching to serve repeated requests instantly.
- Rate limiting and IP blocking for security.
- Response compression to reduce bandwidth.
- Custom headers for CORS and security policies.

All of this is controlled by a single nginx.conf file. It reloads without downtime.

👉In Kubernetes environments, Nginx serves as an Ingress Controller. It manages and routes traffic to internal services based on paths and rules.

✅That’s why Nginx powers over 400 million websites. It’s not just a web server - it’s a complete traffic management solution.

[Arpit Bhayani @arpit_bhayani]

As software engineers, most of us have an itch to improve - to become better at coding, architecture, or leadership. But do you see the problem? It's all fuzzy and vague.

I follow a simple flow of questions that helps me stay focused, improve consistently, and make an incremental impact at the workplace. I'm never running around like a headless chicken. Here are the questions I ask myself, and answer honestly, like really true to its core

- Why do I want to improve today? What's the need?
- What niche do I want to improve in?
- What are the easiest 20% of things that cover 80% of the results?
- How will I go about doing this in the span of X weeks?
- How will I measure that I am improving at this?

Each question above is critical because it gives you clarity. By the way, if you don't have a strong reason, you'll never sustain the effort. Honestly, in that case, it's better to just relax and watch that movie you've been meaning to see.

Also, many engineers never grow out of the school mindset. They make daily timetables, literally planning every single hour of the day. Don't do that. Remember: what you need is a broad plan, not granular control; a roadmap, not a prison schedule.

Here are a few things that I have been doing consistently...

1. I use AI as a planner and tweak it to my needs
2. I study people I admire, and I pick one or two traits (not ten)
3. I pair every small milestone with an action and an artifact - in my case, a blog, a video, or a social media post.

Aspirations are essential as they give you direction, but what's super important is to pick the right niche and execute with focus.

At the end of the day, growth isn't about doing everything, it's about doing the right things with consistency. Don't chase ten different skills at once, and don't over-engineer your plan.

[Arpit Bhayani @arpit_bhayani]

For every complex problem, there is often a simpler solution that works 90% of the time and takes only 10% of the effort. Prioritize that. I'll give you an example...

Say, on a social app, when a user posts something and immediately tries to read it, there's a chance the read request goes to a replica that doesn't yet have the data. As a result, the user may receive a 404 error.

Instead of chasing read-your-write consistency or even strong consistency, you could simply enhance the UX for most users by adding a 3-second animation on the screen, giving replicas enough time to catch up.

This "solves" read-your-write consistency "enough" that most of your users would be happy, and hence it's a perfectly valid solution.

Remember, your job is to solve problems that have the highest impact in the least amount of time and effort. There is no one right way to solve things in the real world.

Impact matters more than perfection.

[Undefined. @Lakshyaing]

@SwapAgarwal Share the link please

[Dr Milan Milanović @milan_milanovic]

𝗛𝗼𝘄 𝘁𝗼 𝘀𝗲𝗹𝗲𝗰𝘁 𝗗𝗲𝘀𝗶𝗴𝗻 𝗣𝗮𝘁𝘁𝗲𝗿𝗻?

Selecting the correct design pattern in software engineering is crucial for effective problem-solving.

This guide streamlines the process, enabling you to make informed decisions between patterns based on your specific needs.

It provides concise descriptions and valuable use cases for each pattern, making it easier to understand and apply them in real-world scenarios.

To select a pattern, we must first go through the problem identification. If the problem is related to:

🔸 Object Creation? → Creational Patterns
🔸 Object Assembly? → Structural Patterns
🔸 Object Interactions? → Behavioral Patterns

So, let's dive in.

𝟭. 𝗖𝗿𝗲𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀
🔹 Singleton: Use when a single instance of a class is needed. Some examples are logging and database connections.
🔹 Factory Method: Decouple object creation from usage. For example, you create different types of database connections based on configuration.
🔹 Abstract Factory: Create families of related objects. For example, I build parsers for different file formats (e.g., JSON, XML, CSV).
🔹 Builder: Constructing complex objects step by step. For example, if you need to create a complex domain object.
🔹 Prototype: Creating duplicate objects and reusing cached objects to reduce database calls.

𝟮. 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗮𝗹 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀
🔹 Adapter: Make incompatible interfaces compatible. For example, it integrates a new logging library into an existing system that expects a different interface.
🔹 Composite: Represent part-whole hierarchies. For example, graphic objects in a drawing application can be grouped and treated uniformly
🔹 Proxy: Control access to objects. For example, lazy loading of a high-resolution image in a web application.
🔹 Decorator: Dynamically add/remove behavior. For example, we are implementing compression or encryption on top of file streams.
🔹 Bridge: Decouple abstraction from implementation. For example, I am separating platform-specific code from core logic.

𝟯. 𝗕𝗲𝗵𝗮𝘃𝗶𝗼𝗿𝗮𝗹 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀
🔹 Strategy: Define a family of algorithms. For example, they allow users to choose different sorting or compression algorithms.
🔹 Observer: Maintain a consistent state by being notified of changes and, for example, notifying subscribers of events in a messaging system.
🔹 Command: Encapsulate a request as an object. For example, I implement undo/redo functionality in a text or image editor.
🔹 State: Encapsulate state-specific behavior. For example, we are handling different states of a user interface element (e.g., enabled, disabled, selected).
🔹 Template Method: Define the skeleton of an algorithm in operation, deferring some steps to subclasses and implementing a base class for unit testing with customizable setup and teardown steps.

Ultimately, we developed the pattern we needed for our problem.

#softwareengineering #programming #softwaredesign

[Undefined. @Lakshyaing]

@sunnykgupta Agents

[GitHub Projects Community @GithubProjects]

https://t.co/YFA0wJjUfe

[Abhinav Upadhyay @abhi9u]

Article: https://t.co/x6xtPZcBm5

[Undefined. @Lakshyaing]

@SwapAgarwal Yes.

[Undefined. @Lakshyaing]

Hey @grok , who is the most famous person to visit my profile.
Dont tag them in the reply.

[Undefined. @Lakshyaing]

@ankushdharkar @Peerlist @X @LinkedIn Yes, much help needed for this.

[Undefined. @Lakshyaing]

@volklub Why such a gulf between VW and Skoda? Did Kylaq make such a difference.

[Undefined. @Lakshyaing]

@VDuddukuri @prasanna_n3314m @volklub There is minimal to no engine noise inside.

[Undefined. @Lakshyaing]

Hmm, select queries bringing the system down.

[Chandra R. Srikanth @chandrarsrikant]

🚨🚨Lack of a transaction status check limiter resulted in incessant requests by banks, leading to UPI downtime

Imp one by @AnandJRAnand
https://t.co/lL33fnlFi1 via @moneycontrolcom

[Undefined. @Lakshyaing]

@hajarechetan1 Congratulations fellow Akoya Baner customer. Enjoy your ride.