Vinit Kumar

New Blog After a Hiatus

Tue, 24 Feb 2026 00:00:00 GMT

I have not written a blog in some weeks.

What Happened

I worked on a big feature at work that took me some months of work and last couple of weeks where we took it live to production. There was an extensive round of testing and that took all my energy and attention.

Why I Stepped Away

I realised I was doing a lot of work at work and also on open source and I started feeling a wee-bit exhausted so I thought it was best to take a break and go easy on myself. And, I am glad that I did that. All my experience tells when to step back and go easy on myself.

What Changed

Now, as the dust has settled from the deployment, I am going to be more active in my blogs. I am also thinking of writing more general topics and not just mostly tech posts.

I also went on a couple vacations. Here are some picture from the same. Enjoy! :)

What’s Next

I am looking forward to writing more regularly and sharing my thoughts and experiences with all of you.

Closing Thoughts

Thank you for sticking with me during the hiatus. I hope you enjoy the content I write going forward.

json2xml v6.0.1: 29x Faster with Native Rust Extension

Fri, 16 Jan 2026 00:00:00 GMT

I’ve been maintaining json2xml for years now. It’s a simple library that converts JSON to XML, and it’s been working fine. But “fine” wasn’t good enough. I wanted it to be fast.

Today, I’m releasing version 6.0.1 with a native Rust extension that makes the library 29x faster.

Why Rust?

Python is great for many things, but raw performance isn’t one of them. When you’re converting large JSON files to XML, every millisecond counts. The pure Python implementation had several performance bottlenecks:

String escaping: Multiple .replace() calls for XML special characters (&, <, >, ", ')
Type dispatch: Chains of isinstance() checks to determine how to serialize each value
String building: Repeated f-string concatenation creating intermediate string objects

Rust eliminates all of these. Single-pass string escaping, compiled match statements for type dispatch, and pre-allocated buffers for string building. Combined with memory safety guarantees, it was the obvious choice.

The Rust Extension Architecture

The Rust code lives in rust/src/lib.rs and exposes these core functions via PyO3:

escape_xml() - Single-pass XML character escaping
wrap_cdata() - CDATA section wrapping
convert_dict() - Recursive dictionary to XML conversion
convert_list() - List to XML conversion with configurable item wrapping
dicttoxml() - Main entry point exposed to Python

The Python signature is preserved exactly:

def dicttoxml(
    obj: Any,
    root: bool = True,
    custom_root: str = "root",
    attr_type: bool = True,
    item_wrap: bool = True,
    cdata: bool = False,
    list_headers: bool = False,
) -> bytes

Automatic Backend Selection

The magic happens in dicttoxml_fast.py, a new hybrid module that automatically selects the fastest available backend:

try:
    from json2xml_rs import dicttoxml as _rust_dicttoxml
    _USE_RUST = True
    LOG.debug("Using Rust backend for dicttoxml")
except ImportError:
    LOG.debug("Rust backend not available, using pure Python")
    _USE_RUST = False

The module also detects features that require Python fallback:

needs_python = (
    ids is not None
    or item_func is not None
    or xml_namespaces
    or xpath_format
)

if not needs_python and isinstance(obj, dict):
    needs_python = _has_special_keys(obj)  # @attrs, @val, @flat

This means if you’re using advanced features like custom item_func callbacks, XML namespaces, or special dict keys for attribute injection, it transparently falls back to Python. For the common case, you get Rust speed automatically.

Handling Edge Cases

One tricky bit was handling very large integers. Rust’s i64 can’t hold Python’s arbitrary-precision integers. Instead of throwing OverflowError and breaking compatibility, the Rust implementation falls back to string representation for numbers outside the i64 range. It’s a sensible trade-off that keeps behavior aligned with the pure Python backend.

I also added compatibility tests for edge cases like item_wrap=False and list_headers=True to ensure both backends produce semantically equivalent output.

CI/CD Setup

Getting the build pipeline right took some work. I set up two new GitHub Actions workflows:

build-rust-wheels.yml:

Builds manylinux, macOS (both Intel and ARM), and Windows wheels via maturin
Tests across Python 3.9, 3.10, 3.11, 3.12, and 3.13
Publishes to PyPI using trusted publishing (no API tokens needed)

rust-ci.yml:

Runs rustfmt and clippy for code quality
Builds the extension across multiple OS/Python combinations
Executes both Rust-specific tests and the existing Python test suite

The benchmark job only runs on pushes to main or manual triggers now, not on every PR. No point slowing down the feedback loop for regular contributions.

Benchmark Results

The benchmark script (benchmark_rust.py) tests various data shapes:

--- Simple Dict ---
 Python: 45.23µs avg
 Rust:   1.54µs avg
 Speedup: 29.37x

--- Nested Dict ---
 Python: 89.12µs avg
 Rust:   3.21µs avg
 Speedup: 27.76x

--- Large List ---
 Python: 234.56µs avg
 Rust:   8.92µs avg
 Speedup: 26.30x

For anyone processing large JSON files or doing batch conversions, this is a game-changer.

Installation

The library maintains 100% backward compatibility. If you’re already using json2xml:

pip install --upgrade json2xml

The Rust extension is bundled in the wheel. If it fails to build on your platform for some reason, you still have the pure Python fallback.

To check which backend you’re using:

from json2xml.dicttoxml_fast import get_backend, is_rust_available

print(f"Backend: {get_backend()}")  # 'rust' or 'python'
print(f"Rust available: {is_rust_available()}")

What I Learned

PyO3 is genuinely impressive. Writing Rust extensions for Python used to be painful, but PyO3 makes it almost pleasant. The maturin build tool handles all the wheel building complexity, and the GitHub Actions integration with trusted publishing means no more manual PyPI uploads.

If you have a Python library with a performance-critical hot path, I’d highly recommend exploring this approach. The setup involves:

Adding a rust/ directory with Cargo.toml and pyproject.toml
Writing your Rust code with #[pyfunction] and #[pymodule] attributes
Using maturin for building: maturin develop --release for local dev
Setting up GitHub Actions with the maturin-action for CI/CD

The initial setup takes some effort, but the payoff is worth it.

Check out PR #267 for all the implementation details, or just grab the new version from PyPI.

Cheers! 🤘

Building json2xml Across Three Languages in One Day

Wed, 14 Jan 2026 00:00:00 GMT

Yesterday was one of those rare days where everything clicks. I spent the day working on my json2xml project across three different language implementations: Python, Go, and Zig. Here’s what I accomplished and how I did it.

Update (Jan 15, 2026): Added cross-linking documentation between all three repos, fuzz testing for the Go version, and educational Zig comments for newcomers. All three repos now feature the unified hero image in their READMEs.

Day 2 Updates (Jan 15)

json2xml-go Improvements

Fuzz testing: Added fuzz tests for dicttoxml functions to catch edge cases and improve robustness
Cross-documentation: README now links to Python and Zig versions with benchmark comparisons
Hero image: Unified branding across all three repos

json2xml-zig Improvements

Educational comments: Added comprehensive comments throughout the codebase to help Zig newcomers understand idiomatic patterns
Better testing: Improved test suite with zig fmt integration and invalid JSON handling
Cross-documentation: Enhanced Related Projects section with comparison table linking to Python and Go versions

The Python CLI (json2xml-py)

The original json2xml library has been around for years, but it always required importing as a Python module. I finally added a proper CLI interface.

What I Built

cli.py: A full-featured command-line tool with the same flags as the Go version
Console script entry point: Install with pip and run json2xml-py directly
Comprehensive tests: 19 CLI-specific tests bringing total coverage to 210 tests

The CLI supports all the conversion options:

# Convert a file
json2xml-py data.json

# Convert a JSON string
json2xml-py -s '{"name": "John", "age": 30}'

# Use XPath 3.1 format with pretty printing
json2xml-py -x -p data.json

# Read from stdin
cat data.json | json2xml-py -

Flags include -w/--wrapper, -r/--root, -p/--pretty, -t/--type, -i/--item-wrap, -x/--xpath, -c/--cdata, -l/--list-headers, -u/--url, -s/--string, and -o/--output.

PR #266 added 1,867 lines including benchmark scripts and ReadTheDocs documentation.

The Go Port (json2xml-go)

I created json2xml-go as a high-performance alternative for when Python isn’t fast enough.

Features Ported

Basic JSON to XML conversion
Custom wrapper/root elements
Type attributes (type="str", type="int", etc.)
Item wrapping for lists
CDATA sections and XML namespaces
XPath 3.1 json-to-xml format
Pretty printing
Custom attributes (@attrs) and values (@val)
Read from file, string, or URL

Production-Ready Touches

I spent time making this production-ready:

CI/CD: GitHub Actions for build, test, lint across Go 1.22-1.24
Linting: Passed golangci-lint and staticcheck with zero issues
Man page: Comprehensive man json2xml-go documentation
Makefile: Easy make install and make uninstall
Apache 2.0 License: Matching the Python version

The code follows Go conventions properly, renaming Json2xml to JSON2xml per Go initialism rules.

The Zig Implementation (json2xml-zig)

For maximum performance, I created json2xml-zig. Zig’s compile-time evaluation and zero-cost abstractions make it blazingly fast.

What It Includes

Full CLI with all conversion options
XPath 3.1 json-to-xml format support
Comprehensive test suite (36 unit tests)
Tests for edge cases: empty objects, numeric keys, unicode, large data handling
Fixed a memory leak in the XPath format function during testing

Benchmarks: The Fun Part

I ran comprehensive benchmarks comparing all implementations:

Implementation	Relative Speed
CPython 3.14.2	1.00x (baseline)
CPython 3.15.0a4	1.16x faster
PyPy 3.10.16	1.22x faster
Go json2xml-go	7.34x faster
Zig json2xml-zig	~100x faster

Key Findings

Go is 7-20x faster than Python implementations
CPython 3.15 shows 13-35% improvement over 3.14 (nice to see Python getting faster)
PyPy excels at large inputs but has JIT overhead for small ones
Zig is ridiculously fast, as expected

AI-Assisted Development

I used Claude Opus 4.5 extensively throughout this work. Having an AI pair programmer helped me move fast across three different languages in a single day. It assisted with:

Porting the Python logic to idiomatic Go and Zig
Writing comprehensive test suites for each implementation
Setting up CI/CD pipelines and linting configurations
Creating man pages and documentation
Running and analyzing benchmarks

The key was having clear ideas about what I wanted to build. The AI helped translate those ideas into working code across unfamiliar territories (I don’t write Zig daily). It’s a force multiplier when you know what you’re building.

Lessons Learned

CLI parity matters: Having the same flags across implementations makes switching seamless
Testing is portable: The test patterns I developed in Python translated directly to Go and Zig
Benchmarking reveals truths: The 7x speedup in Go justified the port for high-throughput use cases
Documentation matters: Man pages and ReadTheDocs integration make tools discoverable
AI accelerates polyglot work: Moving between Python, Go, and Zig in one day would have been much harder without AI assistance

What’s Next

Explore free-threaded Python 3.14t for parallel processing (PR #256 is open with a 1.55x speedup)
Add streaming support for very large JSON files
Consider WASM builds for browser usage

It was a satisfying day of building tools that solve real problems across the performance spectrum. Whether you need the flexibility of Python, the balance of Go, or the raw speed of Zig, there’s now a json2xml for you.

Check out the repos: json2xml | json2xml-go | json2xml-zig

How to Be a Good Programmer in the Age of AI

Thu, 08 Jan 2026 00:00:00 GMT

Introduction

AI models are remarkably capable and can accomplish tasks faster than many new and intermediate developers. Given this, you might wonder why bother upskilling yourself when you can simply prompt your way to solutions with minimal effort. The answer is: it matters more than ever.

Now is the time to leverage AI strategically to accelerate your learning and growth.

Don’t Skip the Fundamentals

The most important rule: don’t dismiss the advice of experienced programmers about AI usage. They’ve written hundreds of thousands of lines of code and built entire applications from scratch, which enables them to evaluate AI-generated code critically and distinguish quality from mediocrity. This skill comes from years of dedicated work.

Yes, you can use the same AI model, but the output quality won’t match what experienced engineers achieve. It’s not just about generating code—it’s about maintaining it. What happens when you generate code for a large application and later lose access to the AI model? Can you understand that code well enough to modify or maintain it on your own?

Reading and understanding code has never been more critical. If you don’t fully comprehend what you’re working with, invest the time to understand it thoroughly.

Computer science fundamentals don’t change much. Data structures, design patterns, and algorithms remain core to programming. With solid fundamentals, you can identify when AI suggests a suboptimal data structure or flawed algorithm, and guide it toward the correct solution. To someone lacking these foundations, a flawed AI solution might appear correct.

AI won’t replace these fundamentals. In fact, those who excel at writing and improving AI-generated code are invariably strong in these areas.

A Practical Workflow for AI-Assisted Development

Plan first. Read the specifications and sketch out the structure of your solution. Write this plan down, then consult AI to think through it with you and catch anything you missed.
Write code by hand. Use an editor or IDE without AI integration, or disable it temporarily. This keeps you sharp and ensures you retain the ability to write code independently.
Generate tests early. Once your code is ready, ask AI to generate test cases based on your plan. Run them. Your hand-written code likely has edge cases you missed, and tests will catch them. Fix the failing tests yourself and look for similar issues. In the AI era, when test-writing costs have plummeted, skipping unit tests is inexcusable.
Get an AI code review. When your code works and matches your plan, ask AI to act as a senior engineer and review it for correctness, maintainability, best practices, and quality. Export this review to a file, open it alongside your code, and work through the feedback methodically. Keep running tests as you make changes.
Write good commit messages. Use AI to generate clear, descriptive commit messages and pull request descriptions. This makes your contributions easier for reviewers to evaluate and appreciate.

Read Good Code and Build Judgment

Invest time in reading well-written code to develop an eye for quality. AI can generate excellent code, but understanding it is your responsibility. If all you did was write prompts and ended up with code you don’t fully understand, you’ve essentially hired a consultant and claimed credit for their work. Short-term wins don’t matter if you’ve created a codebase you can’t maintain.

Know AI’s Strengths and Limits

AI excels as a research assistant and prototyping partner. It’s remarkably good at generating personal projects and scripts where rigor isn’t critical. Production code is a different story. The stakes are higher, and quality matters.

Be Honest About Attribution

Integrity is more important now than ever. Declare the extent of AI-generated code in your work. Don’t claim ownership until you’ve developed a deep understanding of it and could maintain it without AI assistance. Anything less is technical debt, not value.

The Competitive Advantage

AI is a powerful tool in the hands of experienced engineers who maintain strong fundamentals and keep their coding skills sharp. For those who overuse AI without understanding it or prioritize short-term productivity over learning, the outlook is grim. They risk becoming easily replaceable.

Conclusion

This is not the time to relax or cut corners. Work hard to develop solid skills and keep yourself sharp. The programming landscape is transforming rapidly, and no one knows what the field will look like even a year from now. The question isn’t whether to use AI—it’s whether you’ll remain a skilled engineer capable of evaluating and improving what AI produces.

Hello 2026

Tue, 06 Jan 2026 00:00:00 GMT

2026 is here and we are already in the first week. This year, for a change, I don’t want to start with a resolution that feels forced and that we forget about by the end of the first week.

Instead, I want to be more intentional, write more, read much more, and have a lot of fun writing code. I want to write a huge amount of code. I want to pick up one or two new languages and write something useful with them. I have also become very good at using AI effectively over this past year, and I can see it augmenting my work and improving my output by a significant margin. AI is here to stay, and there is no denying that fact. It is also the most significant event in our lifetime as developers.

At the same time, I want to work on many fun projects like writing a compiler and some low-level C code (all handwritten) to sharpen my skills. I am also quite satisfied with my Vim (NeoVim) setup and I don’t want to diverge from it anymore or spend time endlessly configuring it. I have also recently learned about Git worktrees, and I think they change the nature and scope of concurrent work on the same codebase, especially with AI assistance. I have been using Git since 2010 and only recently did I discover Git worktrees, and it is excellent. This is why one should learn the tools they use thoroughly and not just the bare minimum.

I wish you all a good and productive year ahead and a fulfilling life.

The 25x Speedup: Why Python Performance Rules Matter

Sat, 27 Dec 2025 00:00:00 GMT

I recently came across a tweet outlining seven golden rules for Python performance optimization. These rules target critical-path code—the hot loops that determine application performance. I decided to test them by implementing the same signal processing pipeline twice: once following all the rules, and once ignoring them completely.

My golden rules when using Python:
-No Python loops in the critical path (no for, while, comprehensions, or map).
-No Python objects (lists, dicts, tuples) in the critical path: use typed arrays.
-Avoid repeated calls (each Python call costs). Prefer batching, operation fusion,…
— Quant Beckman (@quantbeckman) December 26, 2025

The results exceeded my expectations: 25x faster execution time.

The Seven Golden Rules

The tweet outlined these performance optimization principles:

No Python loops in the critical path (no for, while, comprehensions, or map)
No Python objects (lists, dicts, tuples) in the critical path: use typed arrays
Avoid repeated calls: Prefer batching, operation fusion, or doing everything in one shot
No allocations in the hot path: preallocate and reuse buffers
Avoid branches (if/else) in the critical path: use masks / where / lookup tables
Avoid conversions: list <-> np.array, dtype changes, .astype(...) on the hot path
Avoid I/O and logging inside the hot path (stdout, files, network)

These rules target numerical computing scenarios where performance matters: real-time signal processing, high-frequency trading, scientific simulations, and machine learning inference.

The Test Case: Batch Signal Processing

I implemented a signal processing pipeline that performs four operations on batches of signals:

Normalization: Scale each signal to [0, 1] range
Threshold filtering: Zero out values below a threshold
Moving average smoothing: Apply a sliding window average
Outlier detection: Replace outliers with the mean value

This pipeline processes 50 signals, each 500 samples long—a realistic batch size for real-time processing scenarios.

The Bad Implementation

The bad implementation violates every rule:

def bad_process_signals(signals_list, threshold, outlier_threshold):
    """
    BAD: Uses inefficient patterns.
    
    Problems:
    - Python loops (for loops)
    - Python objects (lists)
    - Allocations in hot path (creating new lists)
    - Repeated calculations
    - Branches (if/else)
    - No preallocation
    """
    results = []  # BAD: Creating new list
    
    for signal in signals_list:
        # BAD: Repeated min/max calls
        signal_min = min(signal)
        signal_max = max(signal)
        signal_range = signal_max - signal_min
        
        # BAD: Creating new list in hot path
        normalized = []
        for val in signal:
            if signal_range > 0:
                normalized.append((val - signal_min) / signal_range)
            else:
                normalized.append(0.0)
        
        # BAD: Creating new list, repeated if/else
        filtered = []
        for val in normalized:
            if val > threshold:
                filtered.append(val)
            else:
                filtered.append(0.0)
        
        # BAD: Moving average with inefficient loop
        smoothed = []
        window_size = 5
        for i in range(len(filtered)):
            start = max(0, i - window_size + 1)
            window = filtered[start:i+1]
            smoothed.append(sum(window) / len(window))  # BAD: Repeated sum/len
        
        # BAD: Repeated mean/std calculations
        mean_val = sum(smoothed) / len(smoothed)
        std_val = np.sqrt(sum((x - mean_val) ** 2 for x in smoothed) / len(smoothed))
        
        # BAD: Creating new list, repeated if/else
        final = []
        for val in smoothed:
            z_score = abs((val - mean_val) / std_val) if std_val > 0 else 0
            if z_score > outlier_threshold:
                final.append(mean_val)
            else:
                final.append(val)
        
        results.append(final)
    
    return results

Violations:

Multiple nested Python for loops
Python lists created and appended to repeatedly
Memory allocations in the hot path
Repeated if/else branches
Multiple passes over the same data
Type conversions between lists and arrays

The Good Implementation

The good implementation follows all seven rules:

class FastSignalProcessor:
    """
    GOOD: Uses optimization principles.
    
    Follows all golden rules:
    1. No Python loops (vectorized NumPy operations)
    2. No Python objects (NumPy arrays only)
    3. Batched operations (process entire batch at once)
    4. Preallocated buffers (no allocations in hot path)
    5. Mask-based logic (no branches)
    6. No conversions (consistent dtype throughout)
    7. No I/O (pure computation)
    """
    
    def __init__(self, signal_length, batch_size, window_size):
        # Preallocate all buffers as NumPy arrays
        self.signal_length = signal_length
        self.batch_size = batch_size
        self.window_size = window_size
        
        self.normalized = np.empty((batch_size, signal_length), dtype=np.float32)
        self.filtered = np.empty((batch_size, signal_length), dtype=np.float32)
        self.smoothed = np.empty((batch_size, signal_length), dtype=np.float32)
        self.final_output = np.empty((batch_size, signal_length), dtype=np.float32)
        
        # Temporary buffers
        self.batch_min = np.empty(batch_size, dtype=np.float32)
        self.batch_max = np.empty(batch_size, dtype=np.float32)
        self.batch_range = np.empty(batch_size, dtype=np.float32)
        self.threshold_mask = np.empty((batch_size, signal_length), dtype=np.bool_)
        self.z_scores = np.empty((batch_size, signal_length), dtype=np.float32)
        self.outlier_mask = np.empty((batch_size, signal_length), dtype=np.bool_)
        self.mean_vals = np.empty(batch_size, dtype=np.float32)
        self.std_vals = np.empty(batch_size, dtype=np.float32)
        
        self.window_norm = np.float32(1.0 / window_size)
    
    def process_batch(self, signals, threshold, outlier_threshold):
        """GOOD: Preallocated buffers, efficient calculations, vectorized operations."""
        # Convert to NumPy array if needed (only once, at entry point)
        if not isinstance(signals, np.ndarray):
            signals = np.array(signals, dtype=np.float32)
        else:
            if signals.dtype != np.float32:
                signals = signals.astype(np.float32, copy=False)
        
        signals = signals.reshape(self.batch_size, self.signal_length)
        
        # Normalize (vectorized)
        np.min(signals, axis=1, out=self.batch_min)
        np.max(signals, axis=1, out=self.batch_max)
        np.subtract(self.batch_max, self.batch_min, out=self.batch_range)
        
        batch_min_2d = self.batch_min[:, np.newaxis]
        batch_range_2d = self.batch_range[:, np.newaxis]
        
        np.subtract(signals, batch_min_2d, out=self.normalized)
        
        range_mask = self.batch_range > 0
        range_mask_2d = range_mask[:, np.newaxis]
        
        np.divide(self.normalized, batch_range_2d, out=self.normalized, where=range_mask_2d)
        np.multiply(self.normalized, 0.0, out=self.normalized, where=~range_mask_2d)
        
        # Threshold filtering (mask-based, no branches)
        np.greater(self.normalized, threshold, out=self.threshold_mask)
        np.multiply(self.normalized, self.threshold_mask, out=self.filtered)
        
        # Moving average (vectorized)
        padded = np.pad(self.filtered, ((0, 0), (self.window_size, 0)), mode='constant')
        cumsum = np.cumsum(padded, axis=1, dtype=np.float32)
        
        cumsum_valid = cumsum[:, self.window_size:]
        cumsum_shifted = cumsum[:, :-self.window_size]
        
        np.subtract(cumsum_valid, cumsum_shifted, out=self.smoothed)
        np.multiply(self.smoothed, self.window_norm, out=self.smoothed)
        
        # Outlier detection (vectorized)
        np.mean(self.smoothed, axis=1, out=self.mean_vals)
        
        mean_2d = self.mean_vals[:, np.newaxis]
        np.subtract(self.smoothed, mean_2d, out=self.z_scores)
        np.square(self.z_scores, out=self.z_scores)
        variance = np.mean(self.z_scores, axis=1)
        np.sqrt(variance, out=self.std_vals)
        
        std_2d = self.std_vals[:, np.newaxis]
        np.subtract(self.smoothed, mean_2d, out=self.z_scores)
        np.divide(self.z_scores, std_2d, out=self.z_scores, where=std_2d > 0)
        np.abs(self.z_scores, out=self.z_scores)
        
        np.greater(self.z_scores, outlier_threshold, out=self.outlier_mask)
        
        np.copyto(self.final_output, self.smoothed)
        np.copyto(self.final_output, mean_2d, where=self.outlier_mask)
        
        return self.final_output

Key optimizations:

All operations vectorized—no Python loops
Preallocated NumPy arrays—no allocations in hot path
Mask-based logic replaces if/else branches
Batch processing—entire batch processed at once
Consistent float32 dtype—no conversions
In-place operations using out= parameter
Precomputed constants—window_norm avoids repeated division

Performance Results

Running the comparison on 50 signals of 500 samples each:

BAD Implementation (inefficient patterns):
  - Python loops (for)
  - Python objects (lists)
  - Allocations in hot path
  - Branches (if/else)
Time: 0.0079 seconds
Result type: <class 'list'> (Python list)

GOOD Implementation (optimized patterns):
  - Vectorized NumPy operations (no Python loops)
  - NumPy arrays (no Python objects)
  - Preallocated buffers (no allocations in hot path)
  - Mask-based logic (no branches)
Time: 0.0003 seconds
Result type: <class 'numpy.ndarray'> (NumPy array)
Speedup: 25.0x faster

The optimized version runs 25 times faster while producing identical results.

Why These Rules Matter

Each rule addresses a specific performance bottleneck:

1. No Python Loops

Python loops execute bytecode interpretation overhead on every iteration. Vectorized NumPy operations run compiled C code, leveraging SIMD instructions and CPU pipelining. This alone provides 10-100x speedup for numerical operations.

2. No Python Objects

Python lists store pointers to objects scattered in memory. NumPy arrays store contiguous blocks of typed data, enabling:

Better CPU cache utilization
SIMD vectorization
Reduced memory overhead
Predictable memory access patterns

3. Batched Operations

Processing entire batches amortizes Python call overhead and enables better vectorization. NumPy operations on large arrays are more efficient than many small operations.

4. Preallocated Buffers

Allocating memory in the hot path causes:

Garbage collection pressure
Memory fragmentation
Cache misses from heap allocations
Unpredictable performance

Preallocating buffers eliminates these issues.

5. Mask-Based Logic

Branch mispredictions stall CPU pipelines. Mask-based operations using boolean arrays enable:

SIMD vectorization
Better CPU pipelining
Predictable execution paths
Vectorized conditional logic

6. No Conversions

Type conversions create temporary arrays, copying memory and adding overhead. Maintaining consistent dtypes throughout eliminates these copies.

7. No I/O

I/O operations are orders of magnitude slower than computation. Keeping the hot path pure computation ensures predictable performance.

Real-World Impact

These optimizations matter most in performance-critical scenarios:

Real-time signal processing: Processing audio, video, or sensor data streams
High-frequency trading: Executing trades in microseconds
Scientific simulations: Running millions of iterations
Machine learning inference: Serving predictions at scale
Game engines: Rendering frames at 60+ FPS

In these domains, a 25x speedup translates to:

Lower latency for real-time systems
Reduced infrastructure costs
Better user experience
Ability to process larger datasets

When to Apply These Rules

These rules target critical-path code—the hot loops that determine application performance. Not all code needs this level of optimization:

Apply these rules to: Hot loops, frequently called functions, batch processing, numerical computations
Don’t apply to: One-time initialization, error handling, configuration parsing, user interface code

Premature optimization wastes time. Profile first, then optimize the bottlenecks.

Key Takeaways

Performance rules have measurable impact: The 25x speedup demonstrates that following best practices produces real results.
Vectorization beats loops: NumPy’s vectorized operations leverage optimized C code and SIMD instructions that Python loops cannot match.
Memory layout matters: Contiguous NumPy arrays enable better cache utilization and vectorization compared to scattered Python objects.
Preallocation eliminates overhead: Allocating buffers once during initialization avoids GC pressure and memory fragmentation in the hot path.
Mask-based logic enables vectorization: Boolean arrays replace branches, allowing SIMD optimization and better CPU pipelining.
Consistency reduces overhead: Maintaining consistent dtypes and avoiding conversions eliminates unnecessary memory copies.
Pure computation is fastest: Removing I/O and logging from hot paths ensures predictable, optimal performance.

Conclusion

Following performance optimization rules isn’t about pedantry—it’s about writing code that executes efficiently. The 25x speedup demonstrates that these principles produce measurable results.

The rules target numerical computing scenarios where performance matters. They require understanding NumPy’s vectorization capabilities, memory layout implications, and CPU architecture considerations. The investment in learning these techniques pays dividends in performance-critical applications.

What performance optimization techniques have you found most impactful? I’d love to hear about your experiences optimizing Python code.

Django CMS Fellows & Community Annual Report 2025: A Year of Extraordinary Contributions

Wed, 03 Dec 2025 00:00:00 GMT

The Django CMS Fellowship Program continues to drive the development and maintenance of one of the most powerful open-source content management systems in the Python ecosystem. This report covers the contributions made by the two Django CMS Fellows—Fabian Braunand Vinit Kumar—from January 1, 2025, to December 3, 2025.

About the Django CMS Fellowship Program

The Django CMS Fellowship Program supports dedicated developers who work on maintaining, improving, and evolving the Django CMS ecosystem. Fellows contribute across multiple repositories, handling everything from critical bug fixes to major feature implementations, code reviews, issue triage, and community support.

This year marks another exceptional period of growth and stability for Django CMS, with significant milestones including the release of Django CMS 5.0, Django 6.0 compatibility work, and continued modernization of the entire ecosystem.

🌟 Community Collaboration: The Heart of Open Source

While the Fellows provide dedicated maintenance, Django CMS thrives because of its vibrant community. This year, 37 community contributors submitted 89 pull requests alongside the Fellows’ work, demonstrating the collaborative spirit that makes open source powerful.

Top Community Contributors

Contributor	PRs	Key Areas
@mrbazzan	16	djangocms-transfer, quickstart, frontend, badges
@wfehr	11	4-migration, stories, core bug fixes
@metaforx	9	djangocms-rest API, OpenAPI schemas
@pierreben	3	djangocms-form-builder improvements
@marbru	3	Frontend image plugin, documentation
@stefanw	3	Multi-site support, menu fixes
@Vincent-Ngobeh	3	Core CMS fixes, apphook handling

Highlighted Community Contributions

API & Headless Development (@metaforx)

feat: Add page search schema extension
feat: add OpenAPI support for “preview” query parameter
docs: init - Documentation initialization

Transfer & Migration Tools (@mrbazzan)

Migration Customization (@wfehr)

Multi-Site & Core Improvements (@stefanw)

Form Builder Enhancements (@pierreben)

Frontend & Documentation (@marbru)

All Community Contributors

We extend our heartfelt thanks to everyone who contributed code in 2025:


@mrbazzan	@wfehr	@metaforx	@Vincent-Ngobeh
@pierreben	@marbru	@stefanw	@macolo
@wesleyboar	@va-lang	@zbohm	@pietzschke
@albanbochsler	@joshyu	@florianschieder	@mhsiddiqui
@h-peters	@benzkji	@marksweb	@invi84
@Aaditya1273	@aymericderbois	@payamnj	@mihalikv
@rvanlaar	@g-builder-0	@mbi	@corentinbettiol
@jrief	@Grosskopf	@FreemanPancake	@ms-18
@theShinigami	@stefan6419846	@nchaourar	@arkain
@krmax44

🐛 Community Issue Reporting

Issue reporting is vital to the health of any open-source project. Community members reported 177 issues this year, helping identify bugs, request features, and improve documentation across the ecosystem.

Top Issue Reporters

Reporter	Issues	Key Areas
@metaforx	16	djangocms-rest API improvements
@mrbazzan	11	Transfer, frontend, testing
@stefan6419846	10	License compliance, attribution
@wfehr	9	Core CMS, migrations, stories
@MacLake	8	Text editor, stories, templates
@corentinbettiol	5	Form builder, alias, stories
@jrief	5	Security, versioning, core
@stefanw	5	CSP compliance, multi-site, menus

Notable Issues That Drove Improvements

Security & Compliance

Remove inline scripts to make templates work with best practice CSP - Led to CSP compliance in django-filer
[BUG] Never trust user input - Security hardening

Core Functionality

[BUG] Copying between langs not handling missing placeholders - Fixed cross-language copying
[BUG] Method CMSPlugin.get_ancestors() is missing - API enhancement
[BUG] django-cms 4.1.5 is incompatible with django 5.2 - Django 5.2 compatibility

Ecosystem Packages

GridRowPlugin: Columns per Row are not saved - Frontend fix
django management command “create_versions” is gone - Versioning tool restored
Missing migration in djangocms-link 5.0.0 - Migration fix

Documentation & UX

Help menu on CMS5 - UX improvement
[DOC] Fix broken links in CONTRIBUTING - Documentation fix
Django 5.2.x LTS support? - Version support clarification

All Community Issue Reporters

79 unique users reported issues in 2025, including:


@metaforx	@mrbazzan	@stefan6419846	@wfehr
@MacLake	@corentinbettiol	@jrief	@stefanw
@marbru	@Grosskopf	@jasperbok	@florianschieder
@dkoenigroer	@svandeneertwegh	@i-salameh95	@bartTC
@pietzschke	@rprader	@TLuesebrinck	@sveetch
@payamnj	@PeterW-LWL	@creimers	@mbi
@ehallein	@alonso-sand	@febsn	@maxnoelp2
@arcanjo45	@k-kramer	@Will-Hoey	@bachvtuan
@agajankush	@aacimov	…and 45 more

Community Statistics Summary

Metric	Count
Community PRs (Human Contributors)	89
Unique Code Contributors	37
Community Issues Reported	177
Unique Issue Reporters	79
Automated PRs (Bots)	181
Total Community + Bot PRs	270

The combination of dedicated Fellowship work and enthusiastic community participation creates a sustainable model for open-source development. Every contribution—whether a major feature, a bug report, or a typo fix—strengthens Django CMS.

Fellow Contributions

Vinit Kumar (@vinitkumar)

Vinit Kumar brings extensive experience in Python, Django, and open-source development to the Fellowship. His contributions this year focused on strategic improvements, CI/CD optimization, and ensuring the ecosystem stays current with the latest Python and Django versions.

Metric	Count
Pull Requests Created	16
Pull Requests Reviewed	136
Issues Opened	2
Issues Commented On	3

Key Contributions

Python 3.14 and Django 6.0 Readiness

Vinit spearheaded efforts to ensure Django CMS and its ecosystem packages are ready for upcoming Python and Django versions:

Added Django 5.2 support to the core test matrix
Implemented Python 3.14 compatibility across multiple packages including djangocms-alias, djangocms-versioning, and djangocms-frontend
Updated CI matrices to include Django 6.0 testing for djangocms-rest, djangocms-versioning, and djangocms-modules

CI/CD Optimization

One of Vinit’s significant contributions was optimizing the continuous integration infrastructure:

Implemented conditional database testing and nightly runs to reduce CI costs while maintaining test coverage
Fixed issues with deprecated GitHub Actions for publishing packages
Improved coverage file uploads and reporting

Ecosystem Maintenance

Vinit contributed to maintaining package quality across the ecosystem:

Prepared release 3.3.3 for django-filer
Added Django 5.2 to the Django CMS core test matrix
Matched test matrices across djangocms-frontend and Django CMS core
Created and maintained the djangocms-react-proj repository for React integration

Code Reviews

With 136 pull requests reviewed, Vinit played a crucial role in maintaining code quality across the Django CMS ecosystem. His reviews covered:

Major feature implementations in Django CMS core
Bug fixes across multiple ecosystem packages
Documentation improvements
CI/CD pipeline updates
Security-related changes

Notable Pull Requests

Fabian Braun (@fsbraun)

Fabian Braun serves as the lead maintainer of Django CMS and brings deep expertise in the CMS architecture. His extraordinary output this year demonstrates unwavering commitment to the project’s success.

Metric	Count
Pull Requests Created	393
Pull Requests Reviewed	471
Issues Opened	24
Issues Commented On	129

Key Contributions

Django CMS 5.0 Release

Fabian led the monumental effort of releasing Django CMS 5.0, which included:

Complete djangocms-frontend JavaScript rewrite removing jQuery dependencies
New design language implementation for Django CMS 5.1
CSP (Content Security Policy) compliance across the board
Improved editor response times through global caching of plugin restrictions
Better database query optimization for edit and structure endpoints

Core Architecture Improvements

Merged the Page and TreeNode models with backwards migration support by @jrief
Implemented async support and middleware updates for Django CMS 5.0+
Added placeholder-level error handling
Created the CMS_ALWAYS_REFRESH_CONTENT setting for better UX
Implemented the new Django CMS design language

JavaScript Modernization

A significant portion of Fabian’s work focused on modernizing the JavaScript infrastructure:

Upgraded JS build pipeline across Django CMS core
Bundled JS files and removed jQuery dependencies from django-filer
Modernized JS build and removed jQuery bundle from djangocms-versioning
Ensured CSP compliance by removing inline scripts

Ecosystem Package Development

Fabian maintained and improved numerous packages:

djangocms-text: Added Tiptap editor support, markdown pasting, configurable block styles
djangocms-frontend: Template components, simpler configuration, inline editing support
djangocms-versioning: Version locking, permission improvements, language menu fixes
djangocms-alias: Static aliases in structure board, CSP-compliant data bridge
djangocms-rest: Menu endpoints, page search, OpenAPI support
djangocms-stories: Complete rewrite and testing infrastructure
djangocms-transfer: Django CMS 5.0 compatibility

Release Management

Fabian orchestrated multiple releases across the ecosystem:

Django CMS 5.0.0, 5.0.1, 5.0.2, 5.0.3, 5.0.4, 5.0.5
Django CMS 4.1.5, 4.1.6, 4.1.7, 4.1.8, 4.1.9
Django CMS 3.11.10
Multiple releases for djangocms-versioning, djangocms-alias, djangocms-text, django-filer, and other packages

Documentation and Community

Updated LTS definitions per board decisions
Improved coding style documentation
Added documentation for toolbar methods
Autogenerated LTS table and core plugin list from ecosystem repository

Notable Pull Requests

Repositories Impacted

The Fellows’ contributions span the entire Django CMS ecosystem:

Core Packages:

django-cms
djangocms-versioning
djangocms-alias
djangocms-moderation

Frontend & UI:

djangocms-frontend
djangocms-admin-style
djangocms-text
djangocms-text-ckeditor5

Content Plugins:

djangocms-link
djangocms-picture
djangocms-snippet
djangocms-file
djangocms-video
djangocms-style
djangocms-icon

API & Headless:

djangocms-rest

Utilities:

django-filer
django-sekizai
django-classy-tags
djangocms-attributes-field
djangocms-transfer

Migration & Tooling:

djangocms-4-migration
cms-template
django-cms-quickstart

Major Milestones in 2025

Django CMS 5.0 Release

The release of Django CMS 5.0 marked a significant milestone:

Complete JavaScript modernization - Removed jQuery dependencies, adopted modern build tooling
CSP compliance - Removed inline scripts across the entire platform
Performance improvements - Optimized database queries and caching strategies
New design language - Fresh, modern UI for the editing experience
Async support - Middleware updates for Django’s async capabilities

Django 6.0 Compatibility

Both Fellows worked extensively on ensuring Django 6.0 compatibility:

Updated deprecated Django APIs
Added Django 6.0 to test matrices across all packages
Fixed compatibility issues early, before Django 6.0’s stable release

Python 3.14 Support

Forward-looking work to ensure Python 3.14 compatibility:

Updated package dependencies
Fixed deprecation warnings
Updated CI/CD pipelines to test against Python 3.14 alphas

The Impact of the Fellowship Program

The Fellowship Program enables sustained, focused development that would be difficult to achieve through volunteer contributions alone. The numbers tell a compelling story:

409 pull requests created - Nearly every day of 2025 saw new code contributed
607 code reviews - Ensuring high-quality contributions from the broader community
132 issues addressed - Responsive support for users and developers

Beyond the numbers, the Fellows have:

Maintained backward compatibility while pushing the platform forward
Ensured security through proactive updates and CSP compliance
Improved developer experience with better documentation and tooling
Supported the community through issue triage and discussions

Looking Ahead

As we close 2025, Django CMS stands stronger than ever:

Django CMS 5.x provides a modern, performant foundation
Django 6.0 compatibility ensures users can adopt the latest Django LTS
Python 3.14 readiness future-proofs the ecosystem
Improved headless capabilities with djangocms-rest opens new use cases

The Fellowship Program continues to prove its value in maintaining one of Python’s most important open-source projects. The dedication shown by Fabian Braun and Vinit Kumar throughout 2025 exemplifies the spirit of open-source contribution.

Supporting Django CMS

If you or your organization benefits from Django CMS, consider supporting the project:

Contribute code - PRs are always welcome
Report issues - Help identify bugs and improvements
Sponsor the Fellowship - Enable continued dedicated development
Spread the word - Share your Django CMS success stories

Visit django-cms.org to learn more about supporting the project.

This report was compiled using contribution data from the django-cms GitHub organization. All statistics reflect contributions made between January 1, 2025, and December 3, 2025.

Thank you to Vinit Kumar and Fabian Braun for their exceptional dedication to Django CMS.

Reposted from here: https://www.django-cms.org/en/blog/2025/12/07/django-cms-fellows-community-annual-report-2025-a-year-of-extraordinary-contributions/

My Open Source Contributions in 2025

Fri, 28 Nov 2025 00:00:00 GMT

    ╔═══════════════════════════════════════════════╗
    ║                                               ║
    ║  ██╗   ██╗██╗███╗   ██╗██╗████████╗           ║
    ║  ██║   ██║██║████╗  ██║██║╚══██╔══╝           ║
    ║  ██║   ██║██║██╔██╗ ██║██║   ██║              ║
    ║  ╚██╗ ██╔╝██║██║╚██╗██║██║   ██║              ║
    ║   ╚████╔╝ ██║██║ ╚████║██║   ██║              ║
    ║    ╚═══╝  ╚═╝╚═╝  ╚═══╝╚═╝   ╚═╝              ║
    ║                                               ║
    ║          [ Open Source Warrior ]              ║
    ║   57 PRs Created | 139 PRs Reviewed           ║
    ║          21 Projects Launched                 ║
    ║                                               ║
    ╚═══════════════════════════════════════════════╝

2025 has been an incredibly productive year for open source contributions. I’ve authored 57 merged pull requests across 20 different repositories, reviewed and approved 139 merged pull requests, and created 21 new projects. This post is a comprehensive retrospective of the year’s work.

Django CMS Fellow: Maintainer Report

As a Django CMS maintainer and fellow, my contributions to the ecosystem span both code authorship and comprehensive code review. In 2025, I authored 11 PRs and reviewed/approved 95 PRs across the Django CMS family of projects.

Authored Contributions (11 PRs)

django-cms (3 PRs)

feat: optimize CI with conditional database testing and nightly runs - CI optimization
chore: change python version - Version management
feat: add django 5.2 to the test matrix - Django 5.2 support

djangocms-versioning (1 PR)

Modernize Python and Django support: Drop Python 3.9, add Python 3.14 and Django 6.0 - Major version support

djangocms-frontend (1 PR)

feat: match django-cms core test matrix - Test alignment

djangocms-rest (2 PRs)

Add Django 6.0 support to CI - Modern Django support
fix: try to fix the issue with coverage files not uploading - Coverage fixes

djangocms-admin-style (1 PR)

fix: issues with deprecated github actions to publish - GitHub Actions updates

django-filer (1 PR)

Chore/prepare 3.3.3 - Release prep

djangocms-react-proj (2 PRs)

feat: add react project - Initial setup
feat: add a basic outline - Project scaffolding

Code Reviews & Approvals (95 PRs)

╔══════════════════════════════════════════════╗
║     Django CMS Ecosystem - PRs Reviewed      ║
╠══════════════════════════════════════════════╣
║ django-cms/django-cms          ██████████ 71 ║
║ djangocms-versioning           ████ 8        ║
║ django-filer                   ███ 5         ║
║ djangocms-alias                ██ 4          ║
║ djangocms-moderation           ██ 3          ║
║ djangocms-link                 █ 2           ║
║ django-classy-tags             █ 2           ║
║ djangocms-snippet              1             ║
║ djangocms-attributes-field     1             ║
║ django-cms-quickstart          1             ║
║                                              ║
║ Total PRs Reviewed:           95             ║
╚══════════════════════════════════════════════╝

The core django-cms project received the majority of review attention with 71 merged PRs covering modernization, bug fixes, and feature development. This review work ensures code quality and consistency across the entire Django CMS ecosystem.

Personal Project Contributions (46 PRs)

Beyond my work as a Django CMS Fellow, I contributed 46 PRs across my personal open source projects and community initiatives.

Contribution Timeline

┌─ Monthly PR Distribution ─────────────────────────────┐
│                                                       │
│ January      ██ (2)                                   │
│ February     ██████ (6)                               │
│ March        █ (1)                                    │
│ April        █████ (5)                                │
│ May          ████ (4)                                 │
│ June         ██████ (6)                               │
│ July         ███ (3)                                  │
│ August       ████ (4)                                 │
│ September    █████ (5)                                │
│ October      ███████████████ (15) ⚡                   │
│ November     ██████ (6)                               │
│                                                       │
└───────────────────────────────────────────────────────┘

October was the most prolific month with 15 PRs merged, primarily focused on Python version updates and theme development.

Top Contributing Repositories

╔════════════════════════════════════════════════╗
║           Repository Activity                  ║
╠════════════════════════════════════════════════╣
║ vinitkumar/json2xml            ████████████ 18 ║
║ vinitkumar/nvim                █████ 5         ║
║ vinitkumar/pdf-joiner          █████ 5         ║
║ django-cms/django-cms          ███ 3           ║
║ vinitkumar/oscura-vim          ███ 3           ║
║ vinitkumar/vinitkumar.me       ██ 2            ║
║ django-cms/djangocms-rest      ██ 2            ║
║ obsidianmd/obsidian-releases   ██ 2            ║
║ vinitkumar/monokai-pro-vim     ██ 2            ║
║ vinitkumar/dark-paper          ██ 2            ║
║                                                ║
║ Other 10 repositories           ✦ 1 each       ║
╚════════════════════════════════════════════════╝

Heaviest Activity Days - Top 10

Days with the most merged PRs, showing peak productivity periods:

╔════════════════════════════════════════════════════════════╗
║            Top 10 Busiest Days of 2025                     ║
╠════════════════════════════════════════════════════════════╣
║                                                            ║
║ 🥇 Wed, Oct 8    ████████ 4 PRs                            ║
║    └─ json2xml sprint: tooling & testing updates           ║
║                                                            ║
║ 🥈 Wed, Nov 5    ████ 2 PRs                                ║
║    └─ nvim: lazy.nvim migration push                       ║
║                                                            ║
║ 🥉 Fri, Oct 24   ████ 2 PRs                                ║
║    └─ Django CMS: test matrix alignment                    ║
║                                                            ║
║ 🏅 Wed, Oct 15   ████ 2 PRs                                ║
║    └─ Obsidian: theme releases                             ║
║                                                            ║
║ 🏅 Thu, Sep 25   ████ 2 PRs                                ║
║    └─ dark-paper: security upgrades                        ║
║                                                            ║
║ 🏅 Sun, Aug 31   ████ 2 PRs                                ║
║    └─ oscura-vim: theme refinements                        ║
║                                                            ║
║ 🏅 Wed, Jun 18   ████ 2 PRs                                ║
║    └─ pdf-joiner & json2xml: features & security           ║
║                                                            ║
║ 🏅 Tue, Jun 10   ████ 2 PRs                                ║
║    └─ json2xml: testing enhancements                       ║
║                                                            ║
║ 🏅 Fri, Feb 21   ████ 2 PRs                                ║
║    └─ json2xml: coverage & dependencies                    ║
║                                                            ║
║ 🏅 Sun, Jan 19   ████ 2 PRs                                ║
║    └─ node-twitter: security upgrades                      ║
║                                                            ║
╚════════════════════════════════════════════════════════════╝

Key Observation: October 8 was the most productive day with 4 simultaneous PR merges, all in the json2xml project focused on Python tooling and testing infrastructure.

json2xml Project (18 PRs)

The most actively maintained project with heavy focus on Python modernization and testing:

Python Modernization & Support:

Tooling & Infrastructure:

Bug Fixes & Features:

Neovim Configuration (5 PRs)

Major modernization with performance improvements - Repository:

feat: replace fzf.nvim with fff.nvim (Nov 27) - Plugin upgrade
Migrate from packer to lazy.nvim with 15x performance improvement (Nov 5) - Major perf win
Lazy nvim migration (Nov 5) - Package manager migration
feat: nvim is lazy now (Aug 23) - Lazy loading
update (Jul 10) - Regular updates

PDF Joiner (5 PRs)

Cross-platform utility development - Repository:

feat: improve linux support - Cross-platform improvements
feat: implement cross-platform PDF joiner with Linux support - Major feature
fix: try automatic release with binary - Release automation
Feat/add GitHub actions ci - CI setup
Add MIT License to the project - Licensing

Theme Development (8 PRs)

Creative work on color schemes and visual design across platforms:

oscura-vim (3 PRs)

obsidian-releases (2 PRs)

monokai-pro-vim (2 PRs)

Security & Maintenance (7 PRs)

Dependency upgrades and security fixes across multiple projects:

Community Contributions (4 PRs)

Private Repository Contributions

╔═════════════════════════════════════════════════╗
║         Private Repo Statistics                 ║
╠═════════════════════════════════════════════════╣
║ PRs to Private Repos:          1                ║
║ Total Public PRs:              56               ║
║ Public/Private Ratio:          56:1             ║
╚═════════════════════════════════════════════════╝

Private Repo PR:

Valpiccola/ApacheAirflow - “(Don’t Merge) Feat/generate lockfile for better local development”

Other Open Source Reviews

Beyond the Django CMS ecosystem, I also reviewed and approved 2 pull requests in other projects:

vinitkumar/json2xml (2 PRs) - Supporting quality assurance for my core project

Meta: This Blog Itself (vinitkumar.me)

As a matter of transparency, this blog repository also saw significant activity in 2025:

Commits: 91 commits to improve the blog infrastructure, styling, and content Blog Posts in 2025:

2025 in Review (Nov 24)
Migrating from Packer to Lazy.nvim: A 15x Faster Startup (Nov 6)
Vibe Engineering with Django: Working with AI Coding Agents (Oct 8)
Monokai Pro for Vim: Bringing Modern Aesthetics to Terminal Editing (Sep 10)
My New AI Workflow: Embracing Command-Line AI Tools (Aug 31)
Go 1.25: Container-Aware Runtime & Developer Experience (Aug 13)
AI Agents, Me, and My Feelings (Jul 18)
PDF Joiner Now Supports Linux (Jul 7)
Books on My Desk (Jun 7)
Future of Error Handling in Go Notes (Jun 5)
Balancing AI Tools in Development (May 7)
Natural Coder (Apr 2)
Oscura Vim - My New Favorite Theme Collection (Mar 28)

Notable Infrastructure Changes:

Restructured navigation and content organization for better UX
Added blog statistics to Bio component
Implemented TIL (Today I Learned) posts support
Upgraded dependencies and accessibility fixes
Refreshed design with improved colorschemes and navigation

Total of 11 blog posts authored in 2025 (plus many TIL entries), reflecting my journey through AI, tools, themes, and technical depth.

New Projects Created in 2025

I also created 21 new projects this year, reflecting diverse interests across themes, utilities, and infrastructure:

Public Projects (11)

Theme & Design Projects:

monokai-ristretto-obsidian - Warm dark theme for Obsidian, ported from Monokai Pro Ristretto
oscura-obsidian - Dark, elegant theme for Obsidian, ported from oscura-vim
oscura-vim - Vim port for Oscura theme from VSCode
monokai-pro-vim - Beautiful Monokai Pro theme variants for Vim

Utility Projects: 5. pdf-joiner - Join PDFs on Mac with ease using native Mac tools 6. gh-action-dashboard - GitHub Actions dashboard tool 7. djangocms-action-dashboard - Dashboard for Django CMS actions 8. django-cms-infographic - Infographics for Django CMS

Community & Learning: 9. address-book - React Router 7 Address Book Tutorial 10. datasette - An open source multi-tool for exploring and publishing data (Fork) 11. smallweb - Kagi Small Web (Forked)

Django CMS: 12. djangocms-react-proj - React-first Django CMS demo project

Private Projects (10)

Infrastructure and personal development projects kept private:

gotchacode-website - Website project
unified-fonts - Font management system
.config-mac - macOS development configuration
.config - Cross-platform configuration files
jobs - Job tracking and management
ApacheAirflow - Airflow experimentation (shared)
IntermediateProxy - Network proxy project (shared)

╔═════════════════════════════════════════════════╗
║         2025 Projects Created                   ║
╠═════════════════════════════════════════════════╣
║ Total New Projects:            21               ║
║ Public Projects:               11               ║
║ Private Projects:              10               ║
║                                                 ║
║ Project Categories:                             ║
║   • Themes & Design:           4                ║
║   • Utilities:                 4                ║
║   • Infrastructure:            3                ║
║   • Community/Learning:        2                ║
║   • Django CMS:                1                ║
║   • Configuration:             2                ║
║   • Other:                     2                ║
╚═════════════════════════════════════════════════╝

Key Themes & Insights

1. Python Modernization

Significant effort modernizing codebases to support latest Python versions (3.14, 3.15) and deprecated versions (3.9). The json2xml project alone had 6 PRs dedicated to Python version updates.

2. Infrastructure & CI/CD

Heavy investment in GitHub Actions, testing infrastructure, and CI/CD pipeline improvements across multiple Django CMS projects and personal projects.

3. Theme Creation

Creative energy went into developing color themes:

Ported existing themes (Monokai Pro, Oscura) to new platforms
Created Obsidian theme variants
Ensured accessibility compliance

4. Performance Optimization

Achieved 15x performance improvement migrating Neovim from Packer to lazy.nvim - a significant quality-of-life improvement.

5. Security Focus

Multiple security updates addressing vulnerabilities in dependencies (Jinja2, mongoose, express, Jekyll).

Public vs Private Distribution

╔═══════════════════════════════╗
║     Contribution Split        ║
╠═══════════════════════════════╣
║                               ║
║  Public  ████████████████     │ 98%
║  Private █                    │ 2%
║                               ║
╚═══════════════════════════════╝

The vast majority of contributions are to public open source projects, reflecting a strong commitment to the open source community.

Quick Stats Summary

╔═════════════════════════════════════════╗
║      2025 OPEN SOURCE SUMMARY           ║
╠═════════════════════════════════════════╣
║  Total PRs Authored       │     57      ║
║  Total PRs Reviewed       │    139      ║
║  Repositories             │     20      ║
║  New Projects Created     │     21      ║
║  Most Active Project      │ json2xml    ║
╚═════════════════════════════════════════╝

Conclusion

2025 has been a year of consistent, high-impact contributions spanning infrastructure modernization, feature development, security improvements, and creative design work. The 57 merged PRs and 21 new projects created represent not just quantity, but a diverse range of contributions across different domains:

Python ecosystem: json2xml, Django CMS family
Infrastructure: CI/CD improvements, Docker, testing
Creative: Theme design for Vim, Obsidian, VSCode
Utility: PDF manipulation, GitHub dashboards
Community: Contributing to Lobsters, Kagi Small Web

Looking forward to continuing this momentum in 2026.

Data accurate as of November 28, 2025

2025 in Review

Mon, 24 Nov 2025 00:00:00 GMT

2025 was the year I stopped fighting change and started embracing it intentionally.

A lot happened this year—some of it planned, most of it a natural evolution of how I think about work, tools, and the craft of building software. Looking back at my writing and projects from these past eleven months, I see clear threads running through: an obsession with performance, a deepening relationship with AI, and an increasing clarity about what actually matters in both code and life.

Let me walk through what shaped this year.

The Great Tooling Migration

This year was dominated by a particular kind of satisfaction: optimizing things until they sing.

In March, I finally sat down and documented my complete Vim setup—both terminal and GUI. This wasn’t just configuration documentation; it was a statement about what I value: minimal, fast, and intentional. The post resonated with people because it wasn’t about using the latest hyped editor. It was about understanding your tools deeply enough that they become invisible.

Then came November. After years of Packer serving me well, I migrated my entire Neovim configuration to Lazy.nvim. The numbers were stark: 1797ms startup time down to 115ms. That’s a 15x improvement. But the real win wasn’t just speed—it was clarity. Lazy.nvim forced me to be more deliberate about when and how plugins load. The result is a setup that’s faster, more maintainable, and honestly more fun to work in.

This migration crystallized something I’ve been thinking about: good tooling isn’t about having more features. It’s about having the right features, loading at the right time, with no unnecessary overhead. That philosophy applies to everything I do now.

The AI Inflection Point

I’ve been writing about AI all year, and my perspective has evolved significantly. In February, I laid out my experience with five major AI platforms: Cursor, Copilot, ChatGPT, DeepSeek, and Claude. My conclusion then was pragmatic but uncertain: these tools are powerful but inconsistent.

By May, I had articulated a workflow that still feels right. AI as a pair programmer, not a code generator. Think deeply, plan with the AI, implement carefully, review critically, and commit with your name on it. This approach acknowledges AI’s genuine usefulness without surrendering agency.

Then in July, I went deeper. “AI Agents, Me, and My Feelings” was me working through something real: the anxiety that comes with powerful tools. If I let AI write most of my code, will I remember it? Will my skills atrophy? The honest answer is: yes, if you’re not careful. But the solution isn’t to avoid AI. It’s to use it strategically.

By August, I had redefined my entire workflow. Out with VSCode-based editors. In with a multi-pane command-line approach: Vim for coding, AI tools running in a dedicated pane, LazyGit for version control. This setup feels native to how my brain works. No distractions, full modularity, room to breathe.

The throughline here is intentionality. AI isn’t a magic wand. It’s a tool that amplifies both your strengths and your weaknesses. Use it to automate the truly tedious work. Use it for research and exploration. Use it as a code reviewer. But the important decisions, the hard thinking, the architecture—that still needs to be you.

Go 1.25: A Runtime Revolution

In August, I dived deep into Go 1.25, and honestly, it energized me. This wasn’t a minor version bump. The container-aware GOMAXPROCS feature solves a problem that’s plagued Go users in Kubernetes environments for years. The experimental Green Tea GC offers 10-40% performance improvements. The trace flight recorder opens debugging possibilities that were previously impossible.

What struck me was how the Go team continues to deliver practical improvements that solve real-world problems. Not for the sake of novelty, but because they understand their users’ pain points. That’s good stewardship of a language.

Books, Focus, and the Deeper Work

In June, I shared my entire reading stack. It wasn’t random—it was deliberate. Books on deep work, focus, systems thinking, distributed systems, Go, and self-mastery. The through-line is clear: I’m investing heavily in understanding how to think better, build better systems, and live more intentionally.

Cal Newport’s “Deep Work” and “Digital Minimalism” kept coming up throughout the year in my writing. There’s something increasingly important about the ability to focus deeply in a world of endless distraction. And I’m not talking about ignoring the world. I’m talking about choosing what deserves your attention.

What I Learned

2024 ended with a commitment to enjoy life more and write more. 2025 delivered on both.

The writing came easier. I published substantial posts on architecture, tooling, and philosophy. Not because I had answers, but because working through the questions publicly helped clarify my own thinking.

The enjoyment part was harder. It’s easy to let work dictate your mood. It’s easy to obsess over optimization until you forget why you’re optimizing in the first place.

But here’s what shifted: I got clearer about what actually matters. It’s not about having the perfect setup (though I do like good tooling). It’s about using the time you have—with your family, with your work, with your learning—to build something you’re proud of. And doing that consistently, without burning out.

The daily short blog posts in February were an experiment in this. Just showing up every day, writing something, nothing fancy. Some worked, some didn’t. The point was the consistency and the honesty.

What’s Next

As I head into the last month of 2025, here’s what’s clear:

Tooling is increasingly a choice, not destiny. You can have a world-class development environment without subscribing to whatever’s hyped this quarter. Be intentional.
AI is real, and the early adopters who figure out how to work alongside it (not let it work for them) will be far ahead. This isn’t about replacing developers. It’s about augmenting human judgment with machine capability.
Deep work is rarer and more valuable than ever. The ability to think through a complex problem, implement it well, and ship it—that skill doesn’t get cheaper.
Books still matter. In a world of tweets and hot takes, a well-written book that makes you think differently is increasingly precious.
Your biggest threat isn’t AI. It’s good developers armed with the superpower of understanding how to use AI well.

Conclusion

2025 was a year of refinement. Not revolutionary change, but steady, intentional improvement. Better tooling. Clearer thinking about AI. A deeper commitment to deep work. More writing. Better reading.

If 2024 was about change and transition, 2025 was about integration—taking the new circumstances and building something stable, sustainable, and genuinely good.

I’m heading into 2026 with more energy, more clarity, and fewer illusions. The tools are good. The challenges are real. The opportunities are enormous. And I’m ready.

If you’re interested in any of the topics I’ve touched on here—from Neovim optimization to practical AI workflows to Go’s newest features—I’d recommend diving into those posts. They go much deeper than what fits in a year review.

What shaped your 2025? I’d love to hear what stuck with you.

Migrating from Packer to Lazy.nvim: A 15x Faster Startup and Why Packer is Dead

Thu, 06 Nov 2025 00:00:00 GMT

In the ever-evolving world of Neovim plugins, staying current isn’t just about features—it’s about performance. My recent migration from Packer to Lazy.nvim didn’t just modernize my setup; it transformed it, delivering a staggering 15x improvement in startup time. Let’s unpack this migration, explore the nitty-gritty changes, and discuss why Packer, once a favorite, has become a relic of the past.

The Packer Exodus: Why I Finally Made the Switch

For years, Packer served me well as my Neovim plugin manager. It was the go-to choice when I first embraced Lua-based configurations. But as the ecosystem matured, cracks began to appear:

Stagnation: The repository has seen minimal activity, with pull requests languishing unmerged for months.
Maintenance Burden: The maintainer has shifted focus, leaving users to fend for themselves with bugs and compatibility issues.
Performance Bottlenecks: While functional, Packer lacks the optimizations that modern managers like Lazy offer.

Lazy.nvim, created by the same team behind some of Neovim’s most popular plugins, emerged as the natural successor. It’s not just faster—it’s designed for the way we use Neovim today, with lazy-loading and performance-first architecture.

Diving into the Migration: PR #8 in Detail

This PR migrates the Neovim configuration from Packer to lazy.nvim, replacing the plugin manager while adding performance optimizations like lazy loading. The main file changed is init.lua (+42 additions, -98 deletions). Other files include init.lua.back (backup), lazy-lock.json (new lockfile), and nvim.png (likely an icon update).

Core Changes: From Packer to Lazy

The heart of the migration was replacing Packer’s startup function with Lazy’s declarative setup. Instead of:

packer.startup(function(use)
  use 'wbthomason/packer.nvim'
  use 'junegunn/fzf'
  -- ... (all plugin 'use' calls)
end)

Lazy uses a table-based approach with bootstrap code:

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

-- Setup lazy.nvim
require("lazy").setup({
  -- plugin specs here
})

Lazy-Loading: The Performance Game-Changer

Migrated plugins with Lazy’s sophisticated lazy-loading system, adding event, cmd, keys, build, and dependencies for performance.

Example before (Packer):

use {'neoclide/coc.nvim', branch = 'master', run = 'npm ci'}
use {'tpope/vim-commentary'}
use {'nvim-lualine/lualine.nvim', requires = { 'nvim-tree/nvim-web-devicons', opt = true }}

After (lazy):

{ 'neoclide/coc.nvim', branch = 'master', build = 'npm ci', event = 'BufReadPre' },
{ 'tpope/vim-commentary', keys = { { 'gc', mode = { 'n', 'v' } } } },
{
  'nvim-lualine/lualine.nvim',
  dependencies = { 'nvim-tree/nvim-web-devicons' },
  event = 'VeryLazy'
}

This implements multiple loading strategies:

Event-based loading: Plugins like fzf.vim now load only when the :Files command is invoked
Keymap triggers: nvim-tree loads when pressing <C-n>
Command loading: Plugins like Copilot activate only when needed

Lualine Optimization: Cutting the Fat

Updated lualine config to enable global statusline and remove expensive refresh events:

require('lualine').setup {
  -- ...
  globalstatus = true,  -- Changed from false
  refresh = {
    -- Removed 'CursorMoved' and 'CursorMovedI' events
    statusline = 1000,
    tabline = 1000,
    winbar = 1000,
    refresh_time = 16, -- ~60fps
    events = {
      'WinEnter',
      'BufEnter',
      'BufWritePost',
      'SessionLoadPost',
      'FileChangedShellPost',
      'VimResized',
      'Filetype',
      'ModeChanged',
    },
  },
}

Deferred Setup: Non-Critical Plugins on Ice

Moved non-critical setups into vim.defer_fn() for startup performance:

-- Defer non-critical setup
vim.defer_fn(function()
  require("ibl").setup()
  require("nvim-tree").setup()
end, 0)

This prevents plugins like indent-blankline (ibl) and nvim-tree from blocking the main UI thread during startup.

Code Cleanup: Removing Duplicates

Eliminated duplicate autocmd definitions and redundant code, such as multiple yaml filetype sets and a typescript callback that auto-saved files. Removed about 60 lines without losing functionality.

The Numbers Don’t Lie: Performance Gains

The results speak for themselves:

Before: 1797ms startup time
After: 115ms startup time
Improvement: ~15x faster

That’s the difference between waiting almost 2 seconds and having Neovim ready in under a tenth of a second. In practical terms, this means instant responsiveness when opening files, switching projects, or just launching the editor.

Why Packer is Dead

Packer is showing its age and is barely maintained, with stagnant development and unresolved issues. For peace of mind, moving to lazy.nvim is the best option.

Migration Tips for Fellow Neovim Users

If you’re considering this migration:

Start small: Migrate one plugin at a time to understand Lazy’s syntax
Leverage lazy-loading: Not just for performance, but for cleaner keymap management
Profile first: Use :Lazy profile to identify your biggest performance bottlenecks
Preserve your workflow: Lazy can replicate any Packer functionality with better performance

Conclusion: The Future is Lazy

This migration wasn’t just about faster startups—it was about embracing the future of Neovim plugin management. Lazy.nvim represents the next evolution, combining performance, maintainability, and modern features in a package that’s actively developed and community-supported.

If your Neovim feels sluggish, it’s worth the switch. The 15x improvement in my case might be the extreme end, but even conservative estimates show 3-5x improvements for most users. In the world of text editors, every millisecond counts, and Lazy delivers them in spades.

The code for this migration lives in my nvim config repo, and I’m happy to help if you’re undertaking a similar journey. What’s holding you back from making the switch?

Vibe Engineering with Django: Working with AI Coding Agents

Wed, 08 Oct 2025 00:00:00 GMT

This post builds on the excellent work by Simon Willison and his original concept of “Vibe Engineering.” You can read his original piece here.

I’ve been using AI coding assistants for over two years now—from GitHub Copilot to Cursor—and I’ve seen the landscape evolve rapidly. What started as simple autocomplete has transformed into sophisticated coding agents that can iterate, test, and modify code until they achieve specified goals.

But here’s the thing: there’s a massive difference between letting AI write your code and using AI to amplify your engineering capabilities. That difference is what Simon Willison calls “Vibe Engineering.”

What is Vibe Engineering?

Vibe engineering represents the professional end of the AI-assisted development spectrum—where seasoned engineers accelerate their work with LLMs while staying proudly accountable for the software they produce.

This contrasts with vibe coding: the fast, loose, and entirely prompt-driven approach with no attention to how code actually works.

The term itself is intentionally mischievous. The mismatch between “vibes” and “engineering” captures the absurdity of our current AI moment while establishing a clear distinction from the dismissive “vibe coding” label.

The Rise of Coding Agents

Modern coding agents (Claude Code, OpenAI’s Codex CLI, Gemini CLI) can iterate on code, actively testing and modifying it until achieving specified goals. Experienced engineers are now running multiple agents in parallel, tackling several problems simultaneously.

But here’s the key insight: AI tools amplify existing expertise. The more skills and experience you have as a software engineer, the faster and better your results with LLMs and coding agents.

Best Practices for Agent-Assisted Development

Let me walk you through the essential practices, using a Django application as our practical example throughout.

1. Automated Testing

Robust test suites let agents fly. Without tests, agents may claim success without verification. Test-first development is particularly effective with iterative agents.

Django Example:

# tests/test_models.py
from django.test import TestCase
from django.contrib.auth.models import User
from .models import BlogPost

class BlogPostModelTest(TestCase):
    def test_blog_post_creation(self):
        user = User.objects.create_user('testuser')
        post = BlogPost.objects.create(
            title='Test Post',
            content='Test content',
            author=user
        )
        self.assertEqual(str(post), 'Test Post')
        self.assertTrue(post.created_at)

When working with agents, I start with comprehensive test cases. The agent can then implement features knowing exactly what success looks like.

2. Planning in Advance

Start with high-level plans. Iterate on the plan first, then hand off to the agent. Clear specifications lead to better results.

Django Example:

## Feature: User Profile Management

### Requirements:
- Users can view their profile
- Users can edit basic info (name, bio, avatar)
- Profile updates require authentication
- Avatar uploads should be validated and resized

### API Endpoints:
- GET /api/profile/ - View current user profile
- PUT /api/profile/ - Update profile
- POST /api/profile/avatar/ - Upload avatar

### Database Changes:
- Add bio field to User model
- Add avatar field to User model
- Create migration for new fields

I write detailed specifications like this before unleashing any agent. The clearer the requirements, the better the implementation.

3. Comprehensive Documentation

Agents can only keep a subset of the codebase in context. Good docs enable API usage without reading implementation.

Django Example:

# api/views.py
class ProfileViewSet(viewsets.ModelViewSet):
    """
    ViewSet for managing user profiles.
    
    Provides:
    - list: Get current user's profile
    - update: Update profile information
    - partial_update: Partially update profile
    
    Authentication required for all operations.
    """
    serializer_class = ProfileSerializer
    permission_classes = [IsAuthenticated]
    
    def get_queryset(self):
        return User.objects.filter(id=self.request.user.id)

Write documentation first; let agents implement from it. This approach ensures the agent understands the intended behavior before writing code.

4. Good Version Control Habits

Essential for understanding and undoing agent changes. LLMs excel at Git navigation and tools like git bisect.

Django Example:

# Before starting agent work
git checkout -b feature/user-profiles
git add tests/test_models.py
git commit -m "Add tests for user profile functionality"

# After agent completes work
git add .
git commit -m "Implement user profile API endpoints"
git push origin feature/user-profiles

I always create feature branches and commit frequently. This makes it easy to review agent changes and rollback if needed.

5. Effective Automation

CI/CD, automated formatting, linting, preview environments. LLMs make writing automation scripts easier.

Django Example:

# .github/workflows/django.yml
name: Django CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: 3.11
    - name: Install dependencies
      run: |
        pip install -r requirements.txt
    - name: Run tests
      run: |
        python manage.py test
    - name: Run linting
      run: |
        flake8 .
        black --check .

Automation helps agents repeat tasks consistently and catch issues early.

6. Code Review Culture

Fast, productive code review is critical. Treat agent output like any other code submission.

Django Example:

# Before agent work - I write this
def get_user_profile(user):
    """Get user profile with related data."""
    return User.objects.select_related('profile').get(id=user.id)

# After agent work - I review this
def get_user_profile(user):
    """Get user profile with related data."""
    try:
        return User.objects.select_related('profile').get(id=user.id)
    except User.DoesNotExist:
        return None

I always review agent code critically. In this case, the agent added error handling, which is good, but I need to verify it’s the right approach for our use case.

7. Management-Like Skills

Provide clear instructions and necessary context. Give actionable feedback.

Django Example:

Agent, please implement the user profile API with these specific requirements:

1. Use Django REST Framework ViewSets
2. Include proper serialization for all user fields
3. Add validation for avatar uploads (max 5MB, image files only)
4. Include proper error handling and status codes
5. Write comprehensive tests for all endpoints
6. Follow our existing code style (PEP 8, type hints)

Context: This is part of a social media application where users need to manage their public profiles.

Clear, specific instructions lead to better results than vague prompts.

8. Manual QA Excellence

Beyond automated tests, strong manual testing skills are essential. Preview environments are crucial for safe review.

Django Example:

# settings.py
if DEBUG:
    # Use local file storage for development
    DEFAULT_FILE_STORAGE = 'django.core.files.storage.FileSystemStorage'
    MEDIA_URL = '/media/'
    MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
else:
    # Use S3 for production
    DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'

I always test agent implementations in preview environments before merging. This catches integration issues that automated tests might miss.

9. Research Skills

Identify the best approaches before implementation. Prove concepts before unleashing agents.

Django Example: Before implementing user authentication, I research:

Django’s built-in authentication system
JWT vs session-based authentication
Third-party packages like django-allauth
Security best practices for user management

Only after understanding the landscape do I write specifications for the agent.

10. Knowing When to Use AI

Maintain intuition for when LLMs can be applied. This constantly evolves as tools improve.

Django Example:

Good for AI: Boilerplate CRUD operations, API serializers, basic tests
Not good for AI: Complex business logic, security-critical code, performance optimizations
Depends: Database migrations, configuration management

I use AI for the 80% of code that’s straightforward, but I write the critical 20% myself.

11. Updated Estimation Skills

AI changes project timelines unpredictably. Estimations now depend on new, evolving factors.

Django Example: A feature that used to take 2 days might now take 4 hours with AI assistance, but only if:

I have clear requirements
Tests are already written
The agent doesn’t get stuck on edge cases
I can review and integrate quickly

I’ve learned to factor in AI’s unpredictability when estimating projects.

The Vibe Engineering Mindset

Vibe engineering requires operating at the top of your game: researching approaches, deciding architecture, writing specs, defining success criteria, designing agentic loops, planning QA, and managing your “digital interns.”

It’s not about letting AI do the work—it’s about using AI to amplify your existing expertise while maintaining full accountability for the software you produce.

Why This Matters Now

The next 12-24 months will be critical as many companies integrate AI agents into their main workflows. The engineers who master vibe engineering will have a significant advantage over those who either avoid AI entirely or rely on it blindly.

Remember: These tools are powerful, but you remain accountable for the software produced. The goal isn’t to replace your engineering skills—it’s to amplify them.

What’s your experience with AI coding agents? Are you practicing vibe engineering or falling into vibe coding? I’d love to hear your thoughts.

Monokai Pro for Vim: Bringing Modern Aesthetics to Terminal Editing

Wed, 10 Sep 2025 00:00:00 GMT

I’ve always believed that the right colorscheme makes a profound difference in how we write code. After years of switching between various themes, I found myself constantly drawn back to Monokai Pro in VSCode. Its carefully crafted color palette strikes the perfect balance between vibrant syntax highlighting and comfortable readability.

I wrote this theme in vim colorscheme based on the work from gthelding

But here’s the thing - I spend most of my coding time in Vim. The existing Monokai ports never quite captured what made the Pro version special. So I decided to create a faithful port that brings all six Monokai Pro filters to Vim and Neovim.

Why Another Monokai Theme?

Monokai Pro isn’t just another colorscheme. It represents years of refinement by its original creator, with each color carefully chosen to reduce eye strain while maintaining excellent contrast. The Pro version introduced “filters” - subtle variations that cater to different preferences and lighting conditions.

My port maintains these design principles while ensuring compatibility with both Vim 8+ and Neovim. Every highlight group has been meticulously mapped to preserve the original’s aesthetic integrity.

Six Filters, Six Moods

The beauty of Monokai Pro lies in its versatility. Each filter offers a distinct personality while maintaining the core Monokai DNA:

Classic

The original that started it all. Rich, vibrant colors with that signature Monokai warmth.

Machine

Cool, muted tones perfect for late-night coding sessions. This filter reduces blue light while maintaining excellent readability.

Octagon

A warmer take with enhanced contrast. Ideal for bright environments or when you need that extra bit of visual clarity.

Ristretto

Deep, coffee-inspired browns and creams. This filter feels like coding in your favorite café.

Spectrum

Bold and vibrant, pushing saturation to create a more energetic coding environment.

Light

Yes, a light theme! For those sunny days or well-lit offices where dark themes just don’t work.

Installation and Usage

Getting started is straightforward. If you’re using vim-plug:

Plug 'vinitkumar/monokai-pro-vim'

For Packer.nvim users:

use 'vinitkumar/monokai-pro-vim'

Once installed, switching between filters is simple:

" Set your preferred filter
colorscheme monokai-pro-classic
" or
colorscheme monokai-pro-machine
" or any other filter

Technical Implementation

Creating a faithful port required careful attention to detail. Each highlight group maps to its VSCode equivalent, ensuring consistency across editors. The theme supports:

Full TreeSitter integration for Neovim
Language-specific optimizations for Python, JavaScript, Go, and more
Plugin support for popular tools like NERDTree, fzf, and telescope.nvim
Terminal color integration for a cohesive experience

The implementation uses Vim’s native colorscheme architecture, avoiding external dependencies. This ensures fast loading times and broad compatibility.

Design Philosophy

A good colorscheme does more than just look pretty. It should:

Reduce cognitive load by using color consistently
Highlight important syntax elements without overwhelming
Maintain readability across different file types
Work well in various lighting conditions

Monokai Pro achieves all of these goals through its thoughtful color choices and semantic highlighting approach.

Future Development

This initial release focuses on core functionality and accuracy. Future updates will include:

Additional plugin integrations
Performance optimizations for large files
Custom filter creation tools
Better documentation for theme customization

Try It Today

The theme is available on GitHub. I’ve love it, and it’s transformed my Vim experience.

Whether you’re a long-time Monokai fan or just exploring colorscheme options, give it a try. Your eyes will thank you.

Found this useful? Star the repository or report issues to help improve it.

My New AI Workflow: Embracing Command-Line AI Tools

Sun, 31 Aug 2025 00:00:00 GMT

I’m changing how I work with AI, and it’s about time.

The shift involves working with three or more panes depending on screen resolution, but more importantly, it’s about returning to the command line where I feel most comfortable.

The Problem with Editor-Based AI

I’ve never been a fan of VSCode. Since Cursor Agent is built on VSCode, I had to use it, but I never enjoyed the experience. I’m much more comfortable writing code in Vim, and I’ve always preferred command-line tools over GUI-based solutions.

The irony is that I don’t actually need AI integrated into my editor. Modern AI tools like Claude Code, AMP Code, Gemini CLI, and even Cursor Agent work perfectly from the command line. There’s no compelling reason to confine AI assistance to a single editor pane when I can keep it running in a dedicated side pane.

The New Workflow

My new setup involves multiple panes:

Main coding pane: Vim for actual development

: - AI assistant pane: Command-line AI tools running continuously

LazyGit Pane: I love to be able to see the code diff before making commits and lazygit is an amazing tool. I can also just use fugitive for git inside vim it I am on a lower resolution screen.
Additional panes: For documentation, testing, or other development tasks

This approach gives me the flexibility to use AI assistance without being locked into a specific editor. I can leverage the full power of command-line AI tools while maintaining my preferred Vim workflow.

Why This Works Better

Command-line AI tools offer several advantages:

Flexibility: I can use any AI service without being tied to a specific editor
Consistency: The same AI interface works across different projects and languages
Efficiency: No need to switch between different editor modes or AI integrations
Familiarity: Command-line tools feel natural to someone who prefers Vim
Zen: I feel I work best when there are no distractions and command line is that for me.

The future of AI-assisted development isn’t about cramming AI into every editor. It’s about creating flexible workflows that let developers use AI tools in the way that works best for their individual preferences and development style.

I also could just swap Vim with Pycharm,WebStorm or any other Proper IDE and the workflow would still stay the same and modular. This is the most important part of this workflow. Tommorrow, I could just switch the AI assistant to Claude Code and Gemini CLI and nothing would change for me.

Go 1.25: Container-Aware Runtime, Experimental GC, and Developer Experience Enhancements

Wed, 13 Aug 2025 00:00:00 GMT

Go 1.25 arrives in August 2025, six months after Go 1.24, continuing the reliable cadence that developers have come to trust. While maintaining the Go 1 promise of compatibility, this release delivers significant improvements that will reshape how Go applications behave in containerized environments and provide substantial performance gains through experimental features.

This release focuses on three core areas: intelligent container-aware runtime behavior, an experimental garbage collector that promises 10-40% performance improvements, and comprehensive toolchain enhancements that make development more efficient and debugging more powerful.

Let’s dive into what makes Go 1.25 a compelling upgrade for teams of all sizes.

(This analysis is based on the official release notes from go.dev/doc/go1.25.)

Revolutionary Runtime: Container-Aware GOMAXPROCS

The most significant change in Go 1.25 transforms how Go applications behave in containerized environments. The runtime now automatically adjusts GOMAXPROCS based on container resource limits, solving a long-standing pain point for Kubernetes deployments.

The Container Problem Solved

Previously, Go applications running in containers would set GOMAXPROCS to the number of logical CPUs on the host machine, often ignoring container CPU limits. This led to oversubscription, poor performance, and unpredictable behavior in orchestrated environments.

Before Go 1.25:

# Container with 2 CPU limit on 16-core host
$ docker run --cpus=2 mygoapp
$ # GOMAXPROCS = 16 (ignoring container limit)

Go 1.25 Behavior:

# Same container, now respects CPU bandwidth limit
$ docker run --cpus=2 mygoapp
$ # GOMAXPROCS = 2 (honors container limit)

Dynamic GOMAXPROCS Updates

Go 1.25 goes further by periodically updating GOMAXPROCS if CPU availability changes during runtime. This enables truly elastic applications that can adapt to changing resource constraints without restart.

Why This Matters

Improved Container Performance: Applications automatically optimize for their actual resource allocation, eliminating CPU contention and improving throughput in containerized environments.
Better Resource Utilization: Kubernetes clusters will see more predictable performance and better bin-packing as Go applications no longer oversubscribe CPU resources.
Zero Configuration Required: The runtime handles this automatically. You can disable it with GODEBUG=containermaxprocs=0 if needed, but most applications will benefit from the default behavior.

Impact: Teams deploying Go applications in Kubernetes will see immediate performance improvements and more predictable resource usage without any code changes.

Experimental Garbage Collector: 10-40% Performance Boost

Go 1.25 introduces an experimental garbage collector that represents a fundamental shift in GC design, focusing on improved locality and CPU scalability for small object workloads.

The Green Tea GC

The new garbage collector, enabled with GOEXPERIMENT=greenteagc, redesigns marking and scanning for better performance on modern CPU architectures:

# Enable the experimental GC
$ GOEXPERIMENT=greenteagc go build myapp

Performance Characteristics

The design targets workloads that heavily use the garbage collector, with expected improvements of 10-40% reduction in garbage collection overhead. The benefits are most pronounced in applications that:

Allocate many small objects
Have high allocation rates
Spend significant time in garbage collection

Why You Should Try It

Substantial Performance Gains: Early benchmarks show significant improvements in GC-heavy workloads, translating to better application throughput and reduced latency.
Production Feedback Opportunity: The Go team explicitly encourages developers to test this experimental feature and provide feedback, giving you a chance to influence the future of Go’s runtime.
Future-Proofing: Understanding and testing the new GC design positions your team for when it becomes the default in future releases.

Recommendation: Test the experimental GC in your staging environments, especially if your applications are GC-bound. The potential performance gains make this worth investigating.

Trace Flight Recorder: Debugging Rare Events

Go 1.25 introduces a game-changing debugging tool: the runtime trace flight recorder. This feature addresses the long-standing challenge of capturing execution traces for rare events without the overhead of continuous tracing.

How It Works

The runtime/trace.FlightRecorder API maintains a ring buffer of trace data in memory, allowing you to capture trace snapshots only when needed:

import "runtime/trace"

// Configure flight recorder
config := trace.FlightRecorderConfig{
    Duration: 5 * time.Second,  // Capture last 5 seconds
}

recorder := trace.NewFlightRecorder(config)

// Later, when an interesting event occurs
func handleCriticalEvent() {
    // Capture the last few seconds of execution trace
    file, _ := os.Create("debug-trace.out")
    recorder.WriteTo(file)
    file.Close()
}

Debugging Revolution

This enables new debugging workflows:

Production-Safe Debugging: Continuously record trace data with minimal overhead, only writing traces when problems occur.
Rare Event Capture: Finally debug those hard-to-reproduce issues by capturing execution context around the problem.
Targeted Performance Analysis: Focus trace analysis on specific problematic periods rather than sifting through gigabytes of continuous trace data.

Impact: This transforms runtime tracing from a development-only tool to a production debugging capability, dramatically improving your ability to diagnose complex issues.

Enhanced Development Tools

Go 1.25 significantly improves the developer experience with smarter tools and better debugging capabilities.

Address Sanitizer Integration

The go build -asan flag now enables leak detection by default, helping catch memory management issues in C code integration:

# Build with address sanitizer
$ go build -asan myapp

# Run with leak detection (default in Go 1.25)
$ ./myapp
# Will report memory leaks at program exit

Improved Go Command Features

Several go command enhancements streamline development:

Documentation Server:

# Start local docs and open in browser
$ go doc -http fmt.Printf

JSON Version Information:

# Get build info as JSON
$ go version -m -json mybinary

Module Ignore Directive:

// In go.mod
ignore vendor/legacy-code

Enhanced Vet Analyzers

Two new analyzers help catch common bugs:

waitgroup analyzer: Detects misplaced sync.WaitGroup.Add calls
hostport analyzer: Identifies IPv6-incompatible address construction

Example of hostport analyzer:

// This will trigger a warning
addr := fmt.Sprintf("%s:%d", host, port)  // Won't work with IPv6

// Recommended approach
addr := net.JoinHostPort(host, strconv.Itoa(port))  // IPv6-compatible

Comprehensive Standard Library Improvements

Go 1.25 delivers substantial improvements across the standard library, enhancing functionality without breaking compatibility.

HTTP and Networking

Cross-Origin Protection:

// New CSRF protection middleware
mux := http.NewServeMux()
protected := http.CrossOriginProtection(mux)
http.ListenAndServe(":8080", protected)

Enhanced File Operations:

Windows now supports asynchronous I/O handles
DirFS and Root.FS implement io/fs.ReadLinkFS
Multiple new Root methods for filesystem operations

Improved Testing Experience

Test Attributes:

func TestExample(t *testing.T) {
    t.Attr("category", "integration")
    t.Attr("duration", "slow")
    // Test implementation
}

Better Output Control:

func TestOutput(t *testing.T) {
    writer := t.Output()  // Get io.Writer for test output
    fmt.Fprintf(writer, "Debug info: %v\n", data)
}

Unique Package Performance

The unique package receives significant performance improvements:

More eager value reclamation
Parallel processing
Single-cycle collection for unused handles

This makes the unique package more viable for high-throughput applications that need string interning or value deduplication.

Platform and Architecture Updates

macOS Requirements

Go 1.25 requires macOS 12 Monterey or later, dropping support for older versions. This allows the Go runtime to take advantage of newer system APIs and security features.

Architecture Support

RISC-V Enhancements:

linux/riscv64 now supports the plugin build mode
New GORISCV64=rva23u64 environment variable for RVA23U64 profile

Loong64 Improvements:

Race detector support
C traceback integration with runtime.SetCgoTraceback
Internal link mode for cgo programs

Windows ARM Deprecation: Go 1.25 is the final release supporting the broken windows/arm port, which will be removed in Go 1.26.

Critical Compiler Bug Fix

Go 1.25 fixes a significant compiler bug introduced in Go 1.21 that could incorrectly delay nil pointer checks. Programs that previously executed incorrectly will now properly panic:

// This will now correctly panic (was broken in Go 1.21-1.24)
func main() {
    f, err := os.Open("nonExistentFile")
    name := f.Name()  // Should panic here
    if err != nil {
        return
    }
    println(name)
}

This fix improves program correctness and debugging experience by ensuring nil pointer dereferences are caught immediately.

Should You Upgrade to Go 1.25?

The answer depends on your specific context, but for most teams, the benefits significantly outweigh the minimal risks.

For Container-Native Applications: Absolutely Yes

If you deploy Go applications in Kubernetes or other container orchestrators, the container-aware GOMAXPROCS feature alone justifies the upgrade. You’ll see immediate performance improvements and more predictable resource utilization.

For Performance-Critical Applications: Strongly Recommended

The experimental garbage collector offers substantial performance improvements for GC-heavy workloads. Even if you don’t enable it immediately in production, testing it in staging environments will help you understand its impact on your specific use cases.

For Development Teams: Yes, with Enthusiasm

The enhanced debugging tools, improved vet analyzers, and standard library improvements will make your development process more efficient and help catch bugs earlier in the development cycle.

For Production Services: Proceed with Standard Caution

While Go 1.25 maintains compatibility guarantees, the container-aware runtime behavior represents a significant change. Test thoroughly in staging environments, particularly if you have applications that manually set GOMAXPROCS or rely on specific CPU scheduling behavior.

Migration Strategy

Test in Staging: Deploy Go 1.25 in staging environments first, paying particular attention to container resource usage and application performance.
Monitor Container Metrics: Watch CPU utilization, memory usage, and application throughput in containerized environments.
Experiment with Green Tea GC: Test the experimental garbage collector on representative workloads to understand potential performance gains.
Update CI/CD: Incorporate the new vet analyzers and testing improvements into your development workflow.
Plan for Architecture Changes: If you use affected platforms (macOS, Windows ARM), plan for the requirement changes and deprecations.

Conclusion: A Runtime Revolution

Go 1.25 represents more than an incremental update—it’s a fundamental improvement in how Go applications interact with modern infrastructure. The container-aware runtime, experimental garbage collector, and comprehensive tooling improvements position Go as an even more compelling choice for cloud-native development.

The release demonstrates the Go team’s commitment to practical improvements that solve real-world problems. The container-aware GOMAXPROCS addresses years of deployment friction, while the experimental GC promises substantial performance gains for the future.

For teams running Go in production, especially in containerized environments, Go 1.25 offers immediate, tangible benefits. The risk of upgrading is minimal due to Go’s strong compatibility guarantees, while the potential gains in performance and operational efficiency are substantial.

Start planning your upgrade to Go 1.25. Your infrastructure team will thank you for the improved resource utilization, your performance team will appreciate the GC improvements, and your developers will love the enhanced debugging capabilities.

[TIL] How Not To Install LazyGit on Ubuntu

Tue, 29 Jul 2025 00:00:00 GMT

I am working on an Ubuntu Linux VM at work. So while setting up the project repository, I naturally wanted to install lazygit which is a wonderful TUI for git.

When I got to install it. The normal recommendation was to install using snap with this command:

sudo snap install lazygit which installed it successfully, but was for some reason sandboxed. which means I got errors like this:


vinit in 🌐 vinit in demo on  feat/implement-feat [$?] via 🐹 v1.24.5
❯ sudo chown -R vinit:vinit /home/vinit/demo/.git

vinit in 🌐 vinit in demo on  feat/implement-feat [$?] via 🐹 v1.24.5
❯ lazygit
2025/07/29 06:13:16 An error occurred! Please create an issue at: https://github.com/jesseduffield/lazygit/issues


*fs.PathError open /home/vinit/demo/.git/packed-refs: permission denied
/build/lazygit/parts/lazygit/build/main.go:145 (0x969f74)
/snap/go/9416/src/runtime/proc.go:250 (0x437178)
/snap/go/9416/src/runtime/asm_arm64.s:1259 (0x464d44)

Which is not what you expect to see.

An easy solution was to remove the snap version and install it from go itself.

This is how I fixed it

sudo snap remove lazygit
go install github.com/jesseduffield/lazygit@latest
# Make sure Go binaries are in PATH
export PATH="$PATH:$(go env GOPATH)/bin"

And then it just worked!

AI Agents, Me, and My Feelings

Fri, 18 Jul 2025 00:00:00 GMT

I have been using AI-based editors for a couple of years. At my previous job, I used GitHub Copilot, and more recently, since November 2024, I have been using Cursor. The field of AI is evolving so rapidly that it’s challenging to form a consistent opinion about it. This post outlines some of my feelings on the subject.

AI agents are powerful and useful, but they also present certain dangers. If you let an AI agent write most of your code, you risk creating a codebase that you won’t remember in the long run. Worse yet, if you don’t ask the agent to document its work, you could end up with a mess that is difficult to reason about. Personally, I remember all the code I’ve written and thought about deeply. While an agent can significantly reduce development time by doing the heavy lifting, I find that because I didn’t exert the mental effort myself, I don’t remember the details as minutely as when I write the code from scratch.

However, not using AI agents or some form of AI assistance is not an option either, as it would likely lead to a significant drop in productivity and longer shipping times. So, what should we do?

I can already foresee a significant problem for people who use AI for more than 80% of their work: muscle atrophy. It would be just like the fate of humans in the movie Wall-E.

They became totally atrophied and unable to walk because they didn’t use their muscles anymore. Who is to guarantee that the same fate doesn’t await us if we stop using our brains?

This is the biggest conflict I have. While there are dangers in using AI extensively, there is also a loss in not using it. Personally, I want AI to become like Jarvis, doing the heavy lifting for monotonous tasks that don’t spark creativity. At the same time, it should be dependable and correct most of the time, giving me the time and scope to be creative and tackle the hard bits.

The question is: how can we achieve this with current tooling?

AI-Powered Research: By using tools like ChatGPT and Google AI Studio for deep research, one can accumulate a wealth of information and learn it thoroughly. This would have taken much more time in the pre-AI era. Go deep with this research so you can spot when an agent f**ks up, because you will have the theory to back your judgment. Also, one should always download the research as Markdown or PDF files and maintain a local knowledge repository, even backing it up to Git.
Code Implementation: Think about the implementation in great detail and write some code and tests. Get the AI to write the boilerplate exactly to your liking, and then you can write the non-trivial bits. If you’re getting an AI to write functions or other pieces of code, have it write tests to validate what it wrote, so that it’s covered for any future refactoring.
Vigilant Review: Never blindly trust the code an AI has written. Even if it looks good on the surface, go deep into the implementation and refactor where needed. No model, however strong, is equally capable in all languages and frameworks.
Continuous Learning: While AI shortens the time for writing features and bug fixes, use that free time to learn more and go deeper. If you want job security, in-depth knowledge of the business logic is your only protection.
Intelligent Tooling: Use AI as an elaborate linter, code reviewer, and security analyst. It is seriously great at that. It can also be helpful with performance work, given the extensive training and exposure it has that you might not have.

I firmly believe that people with a strong foundational knowledge of languages and stacks, extensive experience building things, and a good grip on AI—knowing how much and when to use it—will smoke many inexperienced and inefficient developers. Your biggest threat is not AI, but good developers armed with the superpower of AI.

The next 12-24 months will be critical as many companies integrate AI agents into their main workflows.

Anything that can be automated by AI agents will be automated by AI agents.

PDF Joiner Now Supports Linux: Quick Setup Guide

Mon, 07 Jul 2025 00:00:00 GMT

PDF Joiner now supports Linux with automatic tool detection and installation. The tool works on all major Linux distributions and provides the same simple interface as the macOS version.

If you haven’t read about PDF Joiner before, check out my original post about the Mac version where I explain the motivation behind creating this free command-line utility.

Quick Setup

1. Check Your CPU Architecture

First, determine your system architecture:

uname -m

If output is x86_64 → use amd64 binary
If output is aarch64 or arm64 → use arm64 binary

2. Download the Correct Binary

For 64-bit Intel/AMD systems (x86_64):

curl -L https://github.com/vinitkumar/pdf-joiner/releases/download/v1.2.9/pdf-joiner-linux-amd64 -o pdf-joiner

For ARM64 systems (aarch64):

curl -L https://github.com/vinitkumar/pdf-joiner/releases/download/v1.2.9/pdf-joiner-linux-arm64 -o pdf-joiner

3. Make It Executable

chmod +x pdf-joiner

4. Run It

./pdf-joiner file1.pdf file2.pdf file3.pdf

First Run Setup

On first run, the tool automatically:

Detects your Linux distribution
Installs required PDF tools if missing
Asks for sudo permission to install dependencies

Example first run:

$ ./pdf-joiner file1.pdf file2.pdf
No PDF joining tools found. Attempting to install them...
Detected Linux distribution: ubuntu
Installing PDF tools for Ubuntu/Debian...
[sudo] password for user:
PDF tools installed successfully!
Successfully joined PDFs into: combined_20250625_143812.pdf

Supported Linux Distributions

Distribution	Package Manager	Auto-Install
Ubuntu/Debian	apt-get	✅
Fedora	dnf	✅
RHEL/CentOS	yum	✅
Arch Linux	pacman	✅

Usage Examples

Basic joining:

./pdf-joiner file1.pdf file2.pdf file3.pdf

Custom output filename:

./pdf-joiner -o combined_document.pdf file1.pdf file2.pdf file3.pdf

Move to system PATH (optional):

sudo mv pdf-joiner /usr/local/bin/
# Now you can run it from anywhere
pdf-joiner file1.pdf file2.pdf

PDF Tools Used

The tool automatically selects the best available PDF backend:

pdfunite (fastest, preferred)
ghostscript (most compatible)
qpdf (alternative option)

Troubleshooting

Permission denied error:

chmod +x pdf-joiner

Tool not found after installation:

# Reinstall PDF tools manually
sudo apt-get update && sudo apt-get install poppler-utils ghostscript  # Ubuntu/Debian
sudo dnf install poppler-utils ghostscript                              # Fedora
sudo yum install poppler-utils ghostscript                              # RHEL/CentOS
sudo pacman -S poppler ghostscript                                       # Arch Linux

Build from Source (Optional)

git clone https://github.com/vinitkumar/pdf-joiner.git
cd pdf-joiner
go build -o pdf-joiner
./pdf-joiner file1.pdf file2.pdf

GitHub Repository: vinitkumar/pdf-joiner Latest Release: v1.2.9

The Linux support extends PDF Joiner’s reach beyond macOS, making it accessible to developers across all major platforms while maintaining the same privacy-focused, local processing approach that makes it a reliable alternative to online PDF tools.

Books on My Desk

Sat, 07 Jun 2025 00:00:00 GMT

📚 Books on My Desk Right Now

A themed curation for anyone who loves thinking deeply, building well, and living intentionally.

I often rotate through books that either challenge how I think or sharpen how I work. Here’s what’s currently in my reading stack—grouped by themes that matter to me.

🧠 Focus, Productivity & Deep Work

Mastering attention in a distracted world.

Deep Work – Cal Newport One of the most important books I’ve read on achieving meaningful output in today’s distraction-heavy world.
Digital Minimalism – Cal Newport Helps cut digital noise and reclaim intentionality in how we use tech.
Hyperfocus – Chris Bailey Great blend of science and practice on when to zoom in and when to intentionally scatter your focus.
Do It Today – Darius Foroux Short, punchy, and action-oriented. Good for anyone struggling with procrastination.

📈 Self-Mastery & Personal Growth

Mental models, discipline, and growth mindset.

The Almanack of Naval Ravikant – Eric Jorgenson A goldmine of clarity on wealth, happiness, and leverage. I keep coming back to it.
101 Essays That Will Change The Way You Think – Brianna Wiest Big ideas delivered in short essays. Great for reflection and reframing.
Mind Master – Viswanathan Anand Chess legend shares how he stays sharp, focused, and humble. Surprisingly practical.
The Greatest Secret – Rhonda Byrne For those who seek peace and grounding through inner awareness.

💸 Psychology, Communication & Money

Relationships and behavior, where it really counts.

The Psychology of Money – Morgan Housel Simple truths that reframe how I think about money and decisions.
How to Win Friends and Influence People – Dale Carnegie Still relevant, still powerful. Essential read for anyone who works with people.
How to Talk So Kids Will Listen… – Adele Faber & Elaine Mazlish Despite the title, it’s a masterclass in empathetic communication—for parents and leaders alike.

🎯 Life Philosophy & Memoir

Stories and ideas that shape perspective.

Zen and the Art of Motorcycle Maintenance – Robert M. Pirsig Slow, philosophical, and incredibly rewarding. Explores the intersection of logic, art, and living well.
Surely You’re Joking, Mr. Feynman! – Richard P. Feynman Whimsical yet brilliant. Feynman’s curiosity is contagious.
Masters of Doom – David Kushner A thrilling look at creativity, rebellion, and tech entrepreneurship. Highly recommended for builders.

💻 Software Engineering Mastery

For going from good to great in engineering.

Code Complete – Steve McConnell An engineering bible. Every serious developer should read it.
Designing Data-Intensive Applications – Martin Kleppmann Still one of the best books on systems architecture and backend design.
High Performance MySQL – Baron Schwartz et al. Essential if you’re tuning or scaling databases.
Patterns of Distributed Systems – (various authors) Understand and apply foundational patterns behind large-scale apps.

⚙️ Systems Programming & Compilers

For those who love understanding the machine.

C: A Reference Manual – Harbison & Steele Not glamorous, but rock-solid. Deepen your C fundamentals.
Compilers (Dragon Book) – Aho, Lam, Sethi, Ullman If you ever wanted to build a language or understand how they work under the hood—this is it.
Introduction to Algorithms (CLRS) – Cormen et al. The classic on algorithms. Still hard. Still worth it.

🧬 Go Programming Track

If Go is your main tool—this path sharpens it.

Learning Go – Jon Bodner Great intro with just enough depth. Good for onboarding too.
Concurrency in Go – Katherine Cox-Buday Explains goroutines, channels, and concurrency models with clarity.
100 Go Mistakes and How to Avoid Them – Teiva Harsanyi A goldmine of real-world issues and better practices.

This stack fuels both the craft of building software and the art of being thoughtful in life and work. If you’ve read any of these—or have recommendations—I’d love to hear them!

#books #softwareengineering #personalgrowth #deepwork #goprogramming #readinglist #developers

Future of Error Handling in Go Notes

Thu, 05 Jun 2025 00:00:00 GMT

Today, a new blog was published about error handling in Go and their syntactic changes. Here is the quick TLDR:

Go’s error handling—mainly the repetitive if err != nil pattern—has been a top complaint due to its verbosity. Over the years, the Go team explored several syntactic improvements:

2018: check/handle — Introduced as part of the Go 2 discussion, but considered too complex.
2019: try built-in — Simpler, auto-returning on error, but obscured control flow and was widely rejected.
2024: ? operator — Inspired by Rust, cleaner and more intuitive, but still failed to achieve consensus.

Despite intense effort and hundreds of community proposals, none of these changes gained broad support. The Go team has now decided to stop pursuing syntax changes for error handling.

Reasons include:

Lack of community and internal consensus.
Risk of splitting the community over idiomatic style.
Current error handling, while verbose, is explicit and predictable.
In idiomatic Go, well-structured error handling includes adding context or stack traces, making verbosity less of an issue.

Bottom line: Go will keep its current approach to error handling for the foreseeable future.

Redis Creator's Code Philosophy: 10 Programming Principles from Antirez

Fri, 09 May 2025 00:00:00 GMT

Antirez is one programmer I respect a lot. He has a singular approach and style of programming that is both effective and efficient. I have been following him and his blogs for over an decade and its amazing how much you can learn watching him work. He is recently very active on 📺 Youtube and I would highly recommend watching him code and explain.

This tips are compiled from this blogs and his code on Github.

🧠 Write Code Like Salvatore Sanfilippo (antirez)

Drawn from Salvatore Sanfilippo’s blog post on comments and the Redis source code.
Each tip includes concrete actions and examples for you to follow.

1. Write Comments with a Purpose Class – Not a Reflex

Sanfilippo categorizes comments into nine types:

✅ Function
✅ Design
✅ Why
✅ Teacher
✅ Guide
✅ Checklist
❌ Trivial
❌ Debt
❌ Backup

✅ Action → Before committing code, mentally label every new comment. Keep it only if it fits in the first six.

2. Put a Design Comment at the Top of Every Non-Trivial File

He often opens a file with a short essay on how the piece works and why the chosen algorithm won.

✅ Action → Start new modules with a 10–20 line “README-inside-the-file” explaining the approach and discarded alternatives.

3. Use “Why Comments” to Freeze Hidden Reasoning

Lines that seem obvious in a diff often hide performance traps or protocol quirks. He documents those explicitly.

✅ Action → Anytime you touch a conditional or a magic constant, ask: “Will future-me remember why?” If not, write a Why comment.

4. Lower Cognitive Load with Guide Comments and Vertical Rhythm

Redis files often have simple headers like:

/* Free the query buffer */

These serve as section dividers to help skimming.

✅ Action → When a function exceeds ~40 lines, break it into visual blocks using one-line Guide comments.

5. Annotate Dynamic State In Situ

In Redis Lua helpers, he prints the Lua stack after every mutation—so readers never reconstruct it mentally.

✅ Action → For code that mutates state (stack, buffer, etc.), add live commentary after each transformation.

6. Keep the File/Build Surface Tiny

Kilo, his text editor, is <1000 LOC. Redis builds with one make. He avoids unnecessary complexity.

✅ Action →

Favor plain C/C++ (or Go/Rust) and the standard library unless a third-party dependency buys a lot.
Resist new build steps. If one is needed, explain it in the Design comment.

7. Model First, Code Later – “Code is Rewriting”

He compares coding to rewriting paragraphs in a novel—iterate until it reads well.

✅ Action → For greenfield components, plan to rewrite the first version at least once before merging.

8. Short, Single-Purpose Functions with CamelCase Names

Redis helpers like raxSeekGreatest or clientHasPendingReplies are clear, action-oriented, and do one thing.

✅ Action →

Keep functions <100 LOC; if it grows, split it.
Use UpperCamelCase for functions and lowerCamelCase for variables.

9. Prefer Data-Structure-Driven Design

He crafts his own arrays (SDS), radix trees (Rax), and vectors instead of using generic containers.

✅ Action →

Sketch your data structure on paper.
If generic containers hide too much logic or performance, implement a slim, focused version and document it.

10. Use Comments as an Analysis Tool

He sees comments as a tool for rubber-duck debugging—if you can’t explain it clearly, it’s not ready.

✅ Action → Don’t commit until you can explain every non-trivial function in 2–3 sentences that feel obviously true.

🛠️ Putting It into Practice

Start each file with a Design comment.
Code small, single-purpose functions; separate logic using Guide comments.
Review all comments: label them, trim the unnecessary ones, add Why or Teacher comments as needed.
Refactor if a comment feels like an apology or excuse—make the code speak for itself.
Commit with a message that reflects what changed and why, ideally mirroring your Why comments.

Follow this loop and your codebase will begin to read like Redis: direct, self-narrating, and friendly to the next engineer—quite possibly future-you.

📚 Further Reading & Resources

Balancing AI Tools in Development: A Practical Workflow Guide

Wed, 07 May 2025 00:00:00 GMT

I have been using to do my professional work since 2 years when Github Copilot was launched and we got an official subscription from work. Since they I have used Claude, ChatGPT and more recently Cursor AI.

However, these days I am getting mixed feelings about it. I believe getting AI to work in Agent Mode will basically cause brain atrophy and you will loose your ability to reason and program well. So solve this, I would use AI more as a pair programmer or research assistant and not as a code generator. And even in the case, it generates the code it has to to pass all benchmarks and code standards. It is very easy to get overwhelmed by AI and the amount of code it generates.

So from now on, this will be my workflow:

Take the problem statement and think hard about it. Come up with a plan.
Ask the same problem to the AI and use their thinking mode to come up with a plan. See if the plan is similar to mine and if mine can use some ideas from it.
Once the plan is complete, start writing the code with a fast feedback loop and preferably in a test driven way to ensure the code written is correct.
Once the code is written, ask the AI to review the code and suggest improvements. Again, no agentic mode here and I want to write all the code committed from my name. AI can be used to generate documentation but has to be critically reviewed.
Finally, make a MR/PR and then get the review done and there would be cycle of QAs to check my work.
I believe I can use the AI to its strengths and at the same time now weaken my abilities by over relying on it.

That’s it folks! Maybe you get smarter and prosper.

Natural Coder

Wed, 02 Apr 2025 00:00:00 GMT

I am a natural coder. I have always been someone who writes software because I enjoy it. I have over a decade of experience with Python and JavaScript, but I enjoy working with any language or framework and quickly become proficient. However, of late, I have struggled with some aspects, and upon introspection, I realize it boils down to trying to copy others’ styles and ways of working rather than honing my natural abilities and doing something for enjoyment rather than for other goals.

Goals such as trying to prove myself at a new job or cementing my role as an OSS community leader. The problem with these is that I constantly feel under pressure and am not doing it for fun. This will only lead to burnout.

I just want to be my own cheerleader and a reasonable critic, doing honest work every day. On top of these things, I will focus on activities that I enjoy and only spend a limited amount of time on them so that I crave them more and more.

I hate the constant feeding frenzy that short-form content has made us addicted to. So, no more constant dopamine-seeking; I want to do it for fun and enjoyment while writing the best possible code with the tools at hand.

That’s it. That’s the goal. Wish me luck!!

Oscura Vim - My New Favorite Theme Collection

Fri, 28 Mar 2025 00:00:00 GMT

I’ve been coding for quite a while now, and one thing that really matters is having a comfortable theme that doesn’t strain your eyes. I recently created Oscura Vim, a port of the excellent Oscura Theme for VSCode by the Fey team. The original theme’s meticulously curated accent colors and precisely balanced contrast inspired me to bring this sophisticated coding environment to Vim users. I also sought permission from them before publishing my port.

Of course! 🤝 and the port looks great
— T. Costa (@tcosta_co) March 20, 2025

Why Another Theme Collection?

Let’s be honest - there are countless themes out there. However, Oscura (originally crafted by the Fey team) stands out because it actually solves real problems. Following the original design principles, I’ve maintained four variants in the Vim port:

🌙 Dark Themes

Oscura: A deep, rich dark background (#0B0B0F) that’s perfect for late-night coding sessions

Oscura Dusk: A slightly lighter variant (#131419) that works well in various lighting conditions

☀️ Light Themes (NEW!)

I’m excited to announce that I’ve added two new light mode variants to the collection:

Oscura Light: A clean, modern light theme designed for bright environments. Provides excellent readability with a professional appearance.

Oscura Dusk Light: A warm light variant with dusk-inspired colors. Perfect for users who want the benefits of a light theme with warmer, more comfortable tones.

What I particularly love about this theme collection is its high contrast and readability across all variants. When you’re debugging a tricky issue or reviewing pull requests, the last thing you want is eye strain from poor color choices.

Installation and Setup

Setting up Oscura is straightforward. If you’re using Vim-Plug like I do, just add this to your .vimrc:

Plug 'vinitkumar/oscura-vim'

For Neovim users with Lazy.nvim (my current setup), you can configure it like this:

{
  'vinitkumar/oscura-vim',
  lazy = false,  -- We want the theme available at startup
}

After installation, activate any of the four themes by adding one of these lines to your .vimrc:

" Dark themes
colorscheme oscura          " Classic dark
colorscheme oscura-dusk     " Dark dusk variant

" Light themes (NEW!)
colorscheme oscura-light    " Classic light
colorscheme oscura-dusk-light " Light dusk variant

Auto-switching Based on Time

You can even set up automatic theme switching based on the time of day:

function! SetOscuraTheme()
  let hour = str2nr(strftime('%H'))
  if hour >= 6 && hour < 18
    " Daytime - use light theme
    colorscheme oscura-light
  else
    " Nighttime - use dark theme
    colorscheme oscura
  endif
endfunction

" Call on startup
call SetOscuraTheme()

What Makes It Special?

Having used this theme collection for a while now, here’s what stands out:

4 Complete Themes: 2 dark + 2 light variants to suit any preference or lighting condition
Optimized for Productivity: Designed for long coding sessions with excellent eye comfort
High Contrast: Excellent readability in all lighting conditions
Comprehensive Syntax Highlighting: Support for 50+ programming languages
Modern UI Support: Status lines, line numbers, popup menus, and more
Git Integration: Enhanced diff highlighting and merge conflict markers
Search & Visual Mode: Clear highlighting for search results and selections
Plugin Compatibility: Works with popular plugins like LSP, Treesitter, and more

Real-world Usage

I’ve been using Oscura during my daily coding sessions, and it’s made a noticeable difference. The theme maintains good contrast even during those long debugging sessions when you’re trying to track down a particularly nasty bug. The enhanced TypeScript support is particularly useful since that’s what I work with most days.

With the new light themes, I can now seamlessly switch between dark and light modes depending on my environment. The light variants are perfect for bright office environments or daytime coding, while the dark themes remain ideal for late-night sessions.

Sometimes, I switch between the original Oscura and Oscura Dusk depending on the time of day and lighting conditions. The Dusk variants work better during transitional periods, while the classic variants are perfect for consistent lighting environments.

A Note on Requirements

Make sure your Vim setup supports true colors - it makes a huge difference in how the theme renders. You’ll need Vim 7.4 or later, but honestly, you should be on a much newer version anyway.

If you’re looking for a comfortable, eye-friendly theme collection that doesn’t compromise on readability and offers both dark and light options, give Oscura a try. It’s become an essential part of my development setup, and I think you’ll appreciate it too.

Credits

This Vim colorscheme collection is based on the Oscura Theme for VSCode created by the Fey team. Their original design’s color palette and principles guided this Vim port. If you’re a VSCode user, I highly recommend checking out their original theme.

Cheers! 🤘

Mission Statement of Thorstel Ball

Wed, 26 Mar 2025 00:00:00 GMT

Here is a tweet from Thorsten Ball:

Just re-discovered these Programming Principles I wrote down in a note called "Mission Statement" years ago.

I still think I stand by them 100%? pic.twitter.com/uCcaj6KrjG
— Thorsten Ball (@thorstenball) March 25, 2025

Programming Principles

It was amazing to read this, but it was still an image, so I uploaded the image to ChatGPT and asked it to extract the text, which is as follows:

Before all: write code for others.
Working code is not enough.
Write as little code as possible.
Write code to be changed and deleted.
Solve the problem behind the feature.
Nurse your codebase like a garden.
Beauty has a place in software development.
Practice over theory. Theory is fantastic, but be mindful of the gap between practice and theory. And if you don’t see the gap, you need more practice.
Chop up the problem so that each problem is easy to understand and solve.
Be fearless. Never be scared of looking into or touching code.
I want to build robust systems that run for years on their own, that are easy to modify, in which bugs are easily spotted and removed.
I want my systems to do their job and nothing more.
Always strive towards high quality and know when tradeoffs need to be made.
I value simplicity higher than easiness.
“It works” is not good enough.
I have a bad memory and I build systems with that in mind.
I work with other people and the artifacts of my work should reflect that.
Hacking is not programming, nor is professional software development.
The history of the software is as important as its future.
Robustness, simplicity, and maintainability are most important.
The artifacts of my work should do what they promise to do.
I care about my work and what I build.
I love building.
I strive to reduce things to their most simple form.
Elegance.
Remove what’s not necessary.
Carefulness and thoroughness are essential parts of my work, even when going fast.
I strive for my work to be neat and uncluttered — “Ordentlichkeit”.
I invest in my tools. Knowing how my tools work is important. Knowledge of my tools will pay off.
Knowledge further down in the stack gives me more leverage higher up.
I favor the Unix philosophy.
Predictability is more important than “magic”.
I try to work it out on my own, then ask other people.
Asking for help is good. Helping others is good.
I never want to hear myself say: “We do it this way, because we’ve always done it this way”.
I will always write code with debuggability and deletability in mind.
It depends.
Good programmers program a lot. “If you want to get better at benching you need to bench more” “Everybody wants to be a body builder, but nobody wants to lift those heavy ass weights”
If you can do it in a single machine, do it in a single machine.
If you can get away without state: database, cash, memory — do it.
You should have a healthy amount of respect and fear of building distributed systems. If you don’t, you’re either missing something or you don’t know the tools. Knowing how things break is important.
If you think something not only has upsides, but no downsides, you probably haven’t used it enough. Tradeoffs are the name of the game.
Never fall for dogma. If you lean towards a dogmatic view — try the other side. You’ll see why the dogma doesn’t always apply.
In the same vein: watch technologies and domains like a dog go faster.
I always believed that technical debt can be avoided. Now I know:

(1) taking on technical debt can be a conscious decision to go fast

(2) not every bit of debt needs to be repaid immediately, some can linger and is not worth being repaid ever.

Full credit is to Thorsten for sharing it with the world. I hope you find these principles as insightful as I did.

Pour Your Heart Into It

Sat, 15 Mar 2025 00:00:00 GMT

Lately, we’ve been spending a lot of time in coffee shops. Yesterday, at the Starbucks in Amanora, Pune, I noticed a quote on the wall: “Pour Your Heart Into It.”

For some reason, it struck me instantly. Maybe because, right now, I’m struggling with exactly that—fully committing myself to everything I do. It’s not easy. In fact, it’s incredibly difficult. But it’s also worth it, especially when applied to things that truly matter. Learning to work with deep focus is a skill worth mastering.

I want to create meaningful work—work that brings both fulfillment and satisfaction. But doing so requires a mindset shift. Struggling and growing are choices, and seeing life through that lens isn’t always easy. Yet, anything worth achieving demands effort. Nothing comes without hard work.

So, for me, this is a reminder to cut down on distractions and procrastination. To focus. To pour my heart into what matters.

Professional Vim Configuration: Terminal and GUI Setup for Modern Development

Tue, 11 Mar 2025 00:00:00 GMT

As a long-time Vim user, I’ve carefully curated my Vim configuration to create a powerful and efficient development environment. My setup works seamlessly in both terminal Vim and GVim (GUI Vim), providing flexibility depending on my needs. Let me walk you through the key components and explain why I chose them.

Essential Plugins

My plugin setup is minimal but powerful, managed by vim-plug. Here are the core plugins I use:

call plug#begin('~/.vim/plugged')
  Plug 'tpope/vim-commentary'
  Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
  Plug 'junegunn/fzf.vim'
  Plug 'neoclide/coc.nvim', {'branch': 'master'}
  Plug 'tpope/vim-fugitive'
  Plug 'github/copilot.vim'
  Plug 'vimwiki/vimwiki'
call plug#end()

Each plugin serves a specific purpose:

vim-commentary: Quick code commenting
fzf & fzf.vim: Lightning-fast fuzzy file finding and searching
coc.nvim: Modern LSP support for intelligent code completion
vim-fugitive: Git integration
copilot.vim: AI-powered code suggestions
vimwiki: Personal note-taking and wiki system

Smart Environment Detection

One of the interesting features of my setup is automatic theme switching based on macOS’s appearance settings:

function! ChangeBackground()
  set termguicolors
  hi LineNr ctermbg=NONE guibg=NONE
  if system("defaults read -g AppleInterfaceStyle") =~ '^Dark'
    set background=dark
    if has('gui_running')
        colorscheme solarized
        set guifont=Source\ Code\ Pro:h16
    else
        colorscheme base16-bright
    endif
  else
    colorscheme rosepine
    set background=light
  endif
endfunction

This function automatically switches between light and dark themes based on my system preferences. In GVim, it uses Solarized theme with Source Code Pro font, while in terminal it uses different themes optimized for each environment.

File-specific Settings

I use autocommands to set specific configurations based on file types:

augroup filetypedetect
  autocmd BufNewFile,BufRead *.md set filetype=markdown sts=4 shiftwidth=4
  autocmd BufReadPost,BufNewFile *.md,*.txt,COMMIT_EDITMSG set wrap linebreak nolist spell spelllang=en_us complete+=kspell
  autocmd FileType javascript setlocal expandtab sw=2 ts=2 sts=2
  autocmd FileType typescript setlocal expandtab sw=2 ts=2 sts=2
  " ... more file types
augroup END

This ensures consistent formatting across different file types and enables features like spell checking for markdown and text files.

Keyboard Mappings

My configuration includes carefully chosen keyboard mappings for efficiency:

, as the leader key
Quick file navigation with Ctrl-p for file search
Buffer management with Ctrl-b
Git commit browsing with Ctrl-c
Split window navigation with Ctrl-h/j/k/l

GUI vs Terminal Usage

When I need seamless system clipboard integration or want a different visual experience, I use GVim. My configuration detects the GUI environment and applies specific settings:

if has('gui_running')
    colorscheme solarized
    set guifont=Source\ Code\ Pro:h16
endif

The GUI version offers advantages like:

Better system clipboard integration
Custom font rendering with Source Code Pro
No terminal color limitations
Easy menu access for less-used commands

Quality of Life Features

Some notable features in my configuration:

Automatic Trailing Space Removal:

autocmd BufWritePre * :call StripTrailingWhitespace()

Custom Status Line:

I use a lightweight custom status line configuration instead of heavy plugins:

set statusline=
set statusline +=%1*\ %n\ %*            "buffer number
set statusline +=%5*%{&ff}%*            "file format
set statusline +=%3*%y%*                "file type
" ... more status line components

Auto-reload Files:

autocmd FocusGained,BufEnter,CursorHold,CursorHoldI *
    \ if mode() !~ '\v(c|r.?|!|t)' && getcmdwintype() == '' | checktime | endif

This ensures files are automatically reloaded when changed externally.

Code Intelligence with CoC

The configuration includes comprehensive CoC (Conquer of Completion) settings for modern IDE-like features:

Code navigation (go to definition, references)
Intelligent auto-completion
Real-time diagnostics
Code actions and quick fixes

My Neovim Setup

I also maintain a modern Neovim configuration written in Lua, which provides similar functionality with some modern improvements. Here’s a detailed breakdown of my Neovim setup:

Plugin Management with Packer

My Neovim configuration uses Packer as the plugin manager, with a carefully selected set of plugins:

Core plugins like fzf and fzf.vim for fuzzy finding
coc.nvim for LSP support and intelligent code completion
vim-commentary for quick commenting
copilot.vim for AI-assisted coding
Theme-related plugins including tinted-vim and solarized-osaka.nvim

Modern Editing Features

The configuration includes numerous modern editing features:

Smart Indentation and Formatting:

Auto-indentation
Smart tab behavior
Language-specific formatting rules
Proper UTF-8 encoding support

Advanced Folding:

Indent-based folding
Starts with all folds open
Custom fold text display

Enhanced UI Elements:

Line numbers with relative numbering
Custom listchars for whitespace visualization
Modern terminal colors support
Cursor line highlighting

Solarized Osaka Theme Configuration

I use a customized version of the Solarized Osaka theme with specific settings:

Transparent background support
Custom styling for comments and keywords
Adaptive brightness for day/night usage
Special handling for sidebars and floating windows

Smart Background Switching

Similar to my Vim configuration, the Neovim setup includes automatic theme switching based on macOS’s appearance settings:

function SwitchBackgroundAndColorScheme()
  local mac_ui_mode = vim.fn.system('defaults read -g AppleInterfaceStyle')
  mac_ui_mode = mac_ui_mode:gsub('%s+', '')
  if mac_ui_mode == 'Dark' then
    vim.opt.background = 'dark'
    vim.cmd("colorscheme solarized-osaka")
  else
    vim.opt.background = 'light'
    vim.cmd("colorscheme solarized-osaka-day")
  end
end

Advanced Auto Commands

The Neovim configuration includes a comprehensive set of auto commands using the modern Lua API:

File type-specific settings for various languages
Automatic spell checking for documentation files
Special theme handling for markdown and wiki files
Automatic saving for TypeScript files
Custom handling for YAML files

Intelligent Key Mappings

The configuration includes carefully thought-out key mappings:

Leader key set to ,
File navigation with Ctrl-p
Buffer management with Ctrl-b
Git integration with Ctrl-g
Advanced CoC integration for code navigation
Split window management
Tab navigation

CoC Integration

The Neovim setup includes sophisticated CoC integration with:

Tab completion
Intelligent backspace handling
Enhanced enter key behavior
Automatic popup menu navigation

Conclusion

This Vim and Neovim setup provides a powerful development environment that works seamlessly in both terminal and GUI environments. The configuration focuses on:

Fast file navigation and search
Modern code completion and intelligence
Git integration
Automatic environment adaptation
Consistent code formatting
Efficient keyboard mappings

Whether I’m working in the terminal or need the convenience of GUI features, this setup ensures I have all the tools I need for efficient coding.

Here is my current config files for vim: https://github.com/vinitkumar/.vim/raw/refs/heads/master/vimrc

Here is my current Neovim Config: https://github.com/vinitkumar/nvim/raw/refs/heads/main/init.lua

Feel free to use it or borrow some parts.

Fin

Job Security

Tue, 11 Mar 2025 00:00:00 GMT

In the age of layoffs and company closures, job security is a myth. But there are ways to make yourself indispensable. Here are some tips:

Do focused work every single day without fail. Consistency is the key.
Be nice with your colleagues and collaborate effectively.
Keep learning new skills and technologies and be proficient at it.
Learn how to write testable code and have an ability to write good tests.
Don’t waste time on Social Media while at work. It’s a productivity killer.
Try too see the bigger picture and understand how your work fits in the grand scheme of things. Also, foresee if you don’t fit and find a way out of that situation.
Work hard, very hard, every single day. Make it an habit of working hard and trying to improve yourself every single day. Consistency is the key and pays off handsomely in the long run.
Be punctual and respect others time. If you have a meeting at 10:00, be there at 9:55. It shows that you respect others time and are serious about your work.
Being great at what you do is probably the only “Real Job Security” you can have. If you are great at what you do, you will always have a job. Companies will always need people who are great at what they do.
Fin

No Cross Posting In Foreseeable Future

Mon, 10 Mar 2025 00:00:00 GMT

Sharing a blog link on social media and seeing the likes and shares roll in is definitely a dopamine hit, but I’ve decided to stop cross-posting my blog on social media for the foreseeable future.

I have specific goals I want to focus on deeply, and I can’t do that if I’m constantly distracted by Twitter and LinkedIn. From now on, I’ll write whatever I feel like, publish it, and leave it at that—no announcements, no notifications. If someone wants to read, they can subscribe to my blog’s RSS feed or just check in on the website from time to time.

I’m doing this to protect my mental space and avoid getting sucked into the social media vortex. So if you enjoy reading my blog, subscribe to the RSS feed or drop by occasionally.

Cheers!

Simple PDF joiner to Join PDF Files on Mac

Thu, 27 Feb 2025 00:00:00 GMT

I have been quite busy in the last week or so and haven’t had much time to write blog posts. However, today I want to share a simple utility I created to solve an annoying problem - joining PDF files on Mac.

The Problem

Recently, I needed to combine multiple PDF files into a single document. Like many people, I started searching online for PDF joining tools. What I found was frustrating - most tools were either:

Web-based applications requiring file upload (privacy concerns)
Free tools with aggressive upselling tactics
Expensive commercial software with way more features than needed

Then I discovered something interesting - macOS actually has a built-in PDF joining utility! It’s located at:

/System/Library/Automator/Combine PDF Pages.action/Contents/MacOS/join. What my utility does is that it adds a nice interface on top of it and you can just it like this:

Source Code

You can browse the source code here: https://github.com/vinitkumar/pdf-joiner

Installation

You can install it directly from Github Release be following the above steps. This assumes you have wget installed on your local machine, if not please run brew install wget

cd /tmp
wget https://github.com/vinitkumar/pdf-joiner/releases/download/1.0.0/pdf-joiner
sudo chmod u+x pdf-joiner
sudo mv pdf-joiner /usr/local/bin

This should ensure that it is downloaded and is in path, so that you can run the commands below.

Join two PDF files:

pdf-joiner file1.pdf file2.pdf

Join multiple PDF files with a specific output path:

pdf-joiner -o merged.pdf file1.pdf file2.pdf file3.pdf

Join all PDF files in a directory:

pdf-joiner -o merged.pdf /path/to/directory/*.pdf
`-o`: Specify the output file path. If not provided, the output will be saved as `joined-pdf-YYYY-MM-DD-HHMMSS.pdf` in the current directory.

The latest binary can be downloaded from here and installed in /usr/local/bin and can be used as the examples above show the usage.

Hope this tool also helps you join as many PDF files you want without any issues and for free.

Daily Blog Number 7

Tue, 18 Feb 2025 00:00:00 GMT

Everyone has their demons, and I have mine too. I have struggled with consistency, which affected my blogging routine for the past two days. On Sunday, we had a busy day filled with family activities. We enjoyed lunch at a nice Bengali Food restaurant in Viman Nagar. While not particularly fancy, the food there is delicious and reminds me of home cooking. I must confess that I’ve grown weary of typical restaurant fare, and these home-style meals nourish both body and soul. Later that afternoon, we visited Third Wave Coffee in Koregaon Park, one of our family’s favorite cafes. My wife and I appreciate it for its coffee and ambiance, while our son enjoys playing Jenga and savoring cakes or cookies. After returning home, we relaxed while contemplating the upcoming Monday.

Monday began with some stress. I received a message reminding me that I was behind on an important task. This feeling lingered throughout the day, and even after returning from the office, my energy remained low. This also explains my lack of motivation to write a blog post – the inspiration simply wasn’t there.

This morning, after dropping my child at school, I returned home and slept, as I still wasn’t feeling well. I woke up at 11 AM, realizing I was working from home today to accompany my wife to a scheduled appointment. After her appointment, I picked up my son from school. Since it was lunchtime, we dined at another excellent restaurant we’ve been frequenting lately – Global Punjab in Seasons Mall. They serve authentic Punjabi cuisine that we thoroughly enjoy. Following a satisfying lunch, I returned to work and made significant progress on several issues.

After completing my work responsibilities, I focused on helping with dinner preparation. Later, I began coding for Django CMS open-source work. I thoroughly enjoy contributing to open-source projects, and my German colleague is excellent to work with. Now that I’ve recounted the events of the past three days, I’m determined to become more consistent and overcome my inner lazy demon that sometimes prevents me from maintaining daily habits.

Cheers! 🤘

Daily Blog Number 6

Sat, 15 Feb 2025 00:00:00 GMT

Morning

On Saturday morning, we usually try to sleep late since weekends provide our only opportunity for extra rest, but we had a dentist appointment scheduled for 10:30 AM. I served as the designated “Alarm Clock” since my family remains immune to all other wake-up calls. Rising at 8 AM, I took some time to clear my sleepy, foggy mind. My kid and wife woke up shortly after, and we quickly freshened up, had breakfast, and headed to the dentist’s clinic. Despite arriving nine minutes late, they expected us since I had messaged their office beforehand. The procedure lasted about an hour, during which my kid and I kept ourselves entertained - I watched some old episodes of Big Bang Theory while he played games. Afterward, we proceeded to a nearby location for another doctor’s appointment. While my wife attended her appointment, my kid and I enjoyed refreshing watermelon juice and buttermilk.

The afternoons in Pune grow increasingly hot, naturally drawing us toward cold refreshments. After the medical procedures and some shopping, we headed to an excellent Punjabi restaurant for lunch. Our meal consisted of fried rice, chapati, and Chicken Chili, accompanied by more buttermilk. I must confess my love for buttermilk - it’s low in calories and perfect for summer. Though tempted by lassi, my wife reminded me of our sugar-restricted diet, so I contentedly settled for buttermilk instead. Following lunch, I called our music school, where my son studies piano and I learn guitar, requesting an earlier time slot due to our evening plans. Fortunately, they accommodated us. We completed our hour-long class before heading home to drop off our shopping items and continue to our next destination.

We reached the mall within 20 minutes and made a beeline for coffee. Despite being extra cautious after yesterday’s coffee mishap, I managed to err again. While I ordered my usual Vietnamese Shakerato, I selected an Iced Cappuccino for my wife, which proved too watery. She typically prefers sugarless cold coffee with almond milk. I apologized for the mistake and promised to make it up to her.

Afterward, we collected a watch we had left for water damage repair and did some shopping. My wife found several items she liked before I headed for a beard trim. Having recently started maintaining a beard, I’ve discovered it demands considerable effort. Later, hunger struck, but we opted for healthy choices at Subway - my wife and I ordered Chicken Salads while my son enjoyed a Subway sandwich. We then rode our scooter home, hoping to avoid another power outage surprise. Thankfully, we encountered none. My son and I spent some time studying for his upcoming test before he expressed readiness for bed. After putting him to sleep, I decided to write this blog, making up for yesterday’s missed post due to the power cut, while also completing today’s entry. Now that I’ve finished writing, I’ll edit and post it shortly.

I hope you enjoyed reading this account of our day, and I look forward to sharing another story tomorrow. Till then.

Cheers! 🤘

Daily Blog Number 5

Fri, 14 Feb 2025 00:00:00 GMT

Morning: A Welcome Break

The morning started differently today. With half of my kid’s classmates attending a class picnic, we seized the opportunity to catch up on our sleep debt. This break from our usual routine pushed our wake-up time to 10 AM, just 30 minutes before my scheduled meeting.

A quick breakfast of bread and peanut butter fueled both my kid and me before I jumped into the team standup. The meeting efficiently laid out our priorities for the day, setting a clear direction for the tasks ahead.

Technical Challenge and Solution

The day’s primary challenge proved more complex than initially anticipated. After multiple collaborative calls with teammates, we developed a promising solution. I methodically evaluated all possible scenarios, considering both immediate requirements and potential edge cases. The solution appeared solid, though it might require additional refinement in future iterations.

Opening Vim, I transformed our theoretical solution into working code. Interestingly, the planning phase consumed 80% of the day, while the actual implementation took only 20% - a common pattern in software development. This distribution highlights a crucial truth: investing time in planning leads to more scalable, maintainable solutions.

Evening: Family Time and Valentine’s Day Celebrations

The evening shifted focus to family activities, starting with my kid’s skating class. His performance impressed everyone as he won every race he participated in. The new coach’s emphasis on proper technique continues to yield excellent results - a testament to the value of quality instruction.

Valentine’s Day presented the perfect excuse for an impromptu family dinner. We chose our favorite Kerala restaurant, known for its consistently excellent cuisine. The meal proved both delicious and fulfilling.

A Sweet Ending

After dinner, we sought to satisfy my wife’s craving for cold coffee at a nearby bistro. Though the Valentine’s Day special menu replaced coffee with mocktails, we discovered something even better - an interactive dessert experience. The bistro provided a pastry with decorating ingredients, turning our dessert into a creative family activity. Watching my wife and kid collaborate on the decorations, their faces lit with joy, created a memorable moment.

The evening concluded with an unexpected twist - we returned home to find a power outage. Despite concerns about sleeping without cooling, exhaustion won out, and we drifted off to sleep easily.

Below, you’ll find a video capturing the joyful moments of our family’s pastry decoration adventure.

View this post on Instagram

A post shared by | R I T U P A R N A D E Y | 🇮🇳 (@tiadey20)

Daily Blog Number 4

Thu, 13 Feb 2025 00:00:00 GMT

Thursday, February 13th was a good day. I woke up around 5:45 AM, got my kid ready for school, and we prepared for the gym. I reached the gym by 7:35 AM and started my workout.

Today was “Back Day,” and what a painful and exhausting session it turned out to be. Back muscles remain my weakest point, which becomes evident during the reps. My trainer provides great support and helps me build those muscles better. After the gym, I grabbed some nice Idli for breakfast before heading home. Though tired from the gym session, a cold shower helped rejuvenate me. After the shower, I had some egg whites, packed my bags, and left for the office.

The traffic on the way to office was manageable, and I arrived around 11:05 AM. Once there, I grabbed some coffee to get my brain functioning and reviewed the day’s tasks. I read through some articles I wanted to learn from and then started coding. While checking the server logs, I noticed the code hadn’t handled an edge case. I quickly patched it, pushed the code, and left it to the CI Gods to do their job. ;)

My colleague and I went for lunch afterward. The meal proved quite fulfilling, and honestly, in the office environment, I always get a little sleepy after lunch. So, I took a nice 15-minute power nap before focusing back on work. I discussed a major issue with my colleagues, and it seems we found an elegant new approach to solve it. Instead of writing code right away, I decided to document my thoughts and share them with stakeholders. Fortunately, the person who created the ticket agreed with my solution. Tomorrow, I’ll implement the fix and get it working end-to-end. Once done, I packed my bags, grabbed a cold coffee from a café near my office, and drove home. I also picked up some iceberg lettuce on the way, as we’ve been eating chicken salad for dinner every day. If you don’t cook at home, you have no idea how much money you spend on expensive, sub-standard salads. I order chicken from Licious and lettuce from a shop near my office, and believe me, we save around Rs.500 daily compared to restaurant prices. It’s also much healthier since we use the best ingredients at home.

Back home, I had a quick call with my fellow Django CMS Fellow, and we agreed on a testing approach for a major refactor in progress. I feel really positive about the direction we’re taking in the Django CMS project.

Later, I called Mom and Dad and had a good conversation with them. Those of us who have parents, make sure you spend some time talking to them every day. Finally, I’ll leave you with this video from the 2015 Oscars featuring JK Simmons:

Hoping for a better and productive day tomorrow as well.

Cheers! 🤘

Daily Blog Number 3

Wed, 12 Feb 2025 00:00:00 GMT

Another day, another blog. Today was an interesting day. I woke up at 5:45 AM, still a bit tired, but managed to get my kid to school. I was unsure about going to the gym, but still went. Training started a bit later, but it was a tough day. Today was “Shoulder Day” and those muscles are really sore now. However, a sweat session at the gym is somehow the best thing to uplift your mood.

Came back home, had bread and peanut butter (unsweetened), and then did the daily prayer. Also, tried to clean up my wife’s desk a bit (not sure if she has noticed it yet).

Took the standup call from home and then traveled to the office. It was medium traffic and I reached the office in about 15 minutes. Once at the office, had a double espresso with my colleague and then got to work.

It was a decent day at work and made some progress understanding the Go backend for my project. I need to fix a tricky bug, and for that I need to have a really in-depth understanding of the codebase. By the evening, I did some journaling about the day and discovered that Cursor IDE has excellent prompt files like .cursorrules. You can actually configure it on a per-project basis and it can really help streamline the process and the output from AI. As I mentioned in my past post that AI has to be an integral part of your day-to-day work, I am trying to up my game with AI.

Sometimes, I would leave projects midway because I would get demotivated by the scope of work or complexity. With good AI assistance, that’s not an issue anymore. You can tackle problems head-on while counting on AI as a reliable partner. However, I remain cautious and won’t blindly trust code written by AI, just as I wouldn’t blindly trust code written by any human colleague.

Around 5:45 PM, I wrapped up work and headed home. On the way, there’s a bridge, and I was appalled to see the sorry state of the river flowing underneath. In Pune, almost all rivers are in a sorry state. This hits close to home, as I was raised next to a river in my hometown and would go swimming there every weekend and holiday. Few people might relate to the amazing feeling of bathing in fresh river water and having fun.

The pollution is also really concerning, especially when traveling on a two-wheeler. I wear a full-covered helmet and still find it bad. I wish we as people and the government would do something about the poor air quality. At this point, it’s disheartening to think about living and investing in India when these basic necessities cannot be taken for granted.

I really hope we can work towards building a better and more positive world.

Cheers! 🤘

Daily Blog Number 2

Tue, 11 Feb 2025 00:00:00 GMT

Today was a hectic day. It started with getting my kid to school at 7am, and then getting ready as we needed to go back to his school at 9am. I also had to go to the office today, so I had to be ready before that. Last night’s sleep was a bit disturbed and I woke up at least a couple of times. Summer is already here in Pune and it’s not fun at all.

At work, it was a mixed day. Made some progress on the planning, but there are minor roadblocks on other aspects that need more work. I was also making progress with the React Router tutorial, but it got a bit tiring at the end so I dropped it during the day. I made some small fixes to my json2xml project - even though it’s not a lot, it’s still progress. I guess some days, you should just take whatever win comes your way. Coming back from the office, I got a flat tire and that means tomorrow I need to take my Scooty to the tire shop. I hate this hassle, but I guess sometimes there’s no way around it.

Also, in the morning, I went to a nice café with my wife and had my favorite Vietnamese Shakerato - loved it! Now, before going to bed, I want to make some progress with the book I’m currently reading on Kindle called “The Art of Doing Science and Engineering” by Richard W. Hamming.

Hoping for a better and more fulfilling tomorrow.

Cheers! 🤘

Daily Blog Number 1

Mon, 10 Feb 2025 00:00:00 GMT

Writing blog is something that is close to my heart and I thoroughly enjoy the process. It also calms down the chaos inside me. I have decided to write one every single day. It doesn’t have to be long, just one paragraph will do as well as long as I am being honest.

Today morning was a slow start and I didn’t wanted to travel to office. Also, my kid missed his school, so I thought will just work remotely today. In the morning, got some important meetings with teammates and decided on the work that I need to do in the coming few weeks. At work, we are building a very cool feature which would work on all the major OSes. I am lucky to be able to play a major part in this process. I have also been enjoying writing TypeScript quite a bit for this project. The other part of this is in Go and that is quite fun to write a well. Coming from writing Python for 12 straight years, working with Type Safe languages is a breath of fresh air. However, the work is by no means trivial and I am learning /re-learning tonnes while working on it. I am really looking forward to shipping this to all our customers soon.

At Open Source front, I am going to ship a major demo project integrating React with Django CMS. However, React Router has undergone a major update and I need to learn a lot of things. My other team mate in Django CMS, Fabian is on Fire and It’s sometime hard to catch up with him. At the same time, I am proud of the progress we have been making off late.

I have also decided to work on my anger issues. Recently, I have let myself get into stressful situations and I have vowed to not subject myself to those situations anymore and to keep myself first while interacting with folks. Yesterday, I also caught up with my friend from college and his family and we had a nice time. Today, I also missed my Gym Session, as I just wanted to sleep in today. I have accumulated a lot of sleep debt and want to do better on it.

Alright, that’s it for now. Will post another update tomorrow.

Cheers! 🤘

Developer's Guide to AI Tools: Real-world Experience with 5 Leading Platforms

Mon, 03 Feb 2025 00:00:00 GMT

AI has been here for a while now. It is getting significantly better each and every day. There’s no denying the fact that it will continue to improve, and the only way to thrive is to adapt and use it to enhance productivity. Here’s a summary of my AI usage. I use multiple services and haven’t settled on just one yet.

At work, we have a properly configured Cursor AI subscription. GitHub Copilot: I use it for personal projects on my own computer. ChatGPT: I use both the Mac desktop app and the iPhone app. DeepSeek R1:32B: A local LLM I’ve set up on both my work and personal machines using Ollama. Claude: A web-based AI that I use occasionally.

My take on these? Sometimes, they are incredibly powerful, and other times, they spit out pure garbage. The tricky part is having the wisdom to tell the difference.

Here’s my experience with these AI tools:

Cursor AI is nice. I get the hype, but it also confidently skips code or writes incorrect code. If you’re not careful, you’re in deep trouble, my friend. It’s great for some tasks and languages, but when the questions are non-trivial, it tends to mess up.
GitHub Copilot is quite nice, though maybe not at the same level of brilliance as Cursor or ChatGPT.
ChatGPT is probably my most-used AI tool, not just for coding but for a variety of tasks. It’s surprisingly good at handling non-coding-related prompts as well.
DeepSeek is fantastic, and the best part is that I can run it locally using Ollama, eliminating privacy concerns when using AI.
Claude is impressive, and at times, it even outperforms all the others for coding tasks.

Right now, my workflow is still evolving. I see AI as the next great equalizer, a tool that can massively boost productivity when used correctly. I also want to leverage it for deeper research into topics where my understanding isn’t as strong. Additionally, I use AI to catch grammar mistakes in my writing, which I think is a great use case. However, I limit how much editing I allow it to do, often sticking with my original phrasing.

One thing I really dislike is Copilot auto-completing my code and breaking my flow. I’ll probably disable that feature by default and only use it when I actually want it.

Despite the flaws, I’m optimistic about AI’s role in my workflow. It’s not perfect, but neither am I—and together, we can get a lot done.

2024 in Review

Sat, 11 Jan 2025 00:00:00 GMT

2024 was one of the most interesting years of my life.

Family-wise, it was pretty good, and I got to spend time with family and friends. My kid started Grade 1, and it’s so much fun watching him make new friends and have fun with his friends. I also bought a new Guitar and started going to the same Music class my kid goes to for learning Piano. I always had a desire to learn it during college, but I couldn’t afford to do that. My wife has a big role in pushing me to pursue my interest in this.

I also had the first job change of my career. I worked on my last company for almost 12 years and around September 2024, I was informed that my time there was ending. It was a bittersweet moment since the original company was acquired 2 years ago, and the new work was not as fun. I quickly found a great company based in Pune and I am happy to say that I get to do cutting-edge work every day and I am treated very well by my colleagues and the management. Also, after a very long time, I get to work on some pretty challenging stuff and my neurons are firing again like crazy.

My wife and I also made a habit of walking like 5-6km every day after dropping my kid to School and that is one thing I enjoyed the most during the day.

One thing that didn’t turn out great was my time management and sleep. I had a horrible year of sleep and I would really like to focus on getting some good sleep and enjoying life more. I also sometimes let the work dictate my mood and well-being a lot and I would really like to just cut this habit out completely. Also, I want to cut Social Media by a significant percentage and use that time to do something productive or at least fun. Finance-wise, it was an okay-ish year and I want to do better this year.

My Goal this year is to just enjoy life a bit more and be happy. I also want to avoid people who don’t bring joy to my life and surround myself with family and good friends. I am going to do a tonne of OSS work as that is the kind of work I always love doing. I also want to write more and more every day. I believe I can bring a huge change if I am just reasonably consistent and honest with my pursuits.

[TIL] Git Sparse Checkout for Large Repos

Sat, 28 Dec 2024 00:00:00 GMT

Today I learned about git sparse-checkout, a powerful feature that allows you to work with only specific directories in a large repository.

The Problem

When working with monorepos or large codebases, you often only need to work with specific directories, but git clone downloads the entire repository.

The Solution

# Clone without checking out files
git clone --no-checkout <repo-url>
cd <repo-name>

# Initialize sparse checkout
git sparse-checkout init --cone

# Specify which directories to include
git sparse-checkout set src/frontend docs

# Check out the files
git checkout

Key Benefits

Faster clones: Only download what you need
Less disk space: Smaller working directory
Better performance: IDE indexing is faster
Focused development: Reduces cognitive load

When to Use It

Large monorepos
Documentation-only contributions
Feature-specific development
CI/CD optimization

This technique has saved me significant time when contributing to large open-source projects!

[TIL] CSS Container Queries Are Game Changers

Fri, 27 Dec 2024 00:00:00 GMT

Today I discovered the power of CSS container queries, which solve a major limitation of traditional media queries.

The Problem with Media Queries

Media queries only respond to viewport size, not the actual container size. This makes it difficult to create truly reusable components.

/* Traditional media query - viewport based */
@media (max-width: 768px) {
  .card {
    flex-direction: column;
  }
}

Container Queries Solution

/* Container query - container based */
.sidebar {
  container-type: inline-size;
}

@container (max-width: 400px) {
  .card {
    flex-direction: column;
  }
}

Key Advantages

Component-aware: Responds to actual container size
Reusable: Same component works in different layouts
Predictable: Behavior doesn’t depend on viewport
Flexible: Perfect for cards, widgets, and modular components

Browser Support

Container queries are well-supported in modern browsers:

Chrome 105+
Firefox 110+
Safari 16+

Real-World Example

A card component that adapts based on its container width, not the viewport:

.card-container {
  container-type: inline-size;
}

@container (min-width: 300px) {
  .card {
    display: flex;
    align-items: center;
  }
  
  .card-image {
    width: 100px;
    margin-right: 1rem;
  }
}

This enables truly modular, responsive components that work anywhere!

Creating Universal macOS Binaries: A Complete Guide to Fat Binary Generation

Wed, 18 Dec 2024 00:00:00 GMT

So at work, we needed to ship a binary for Mac. With Go, it is super easy to build a binary for any OS and Architecture. However, having separate binaries would mean additional logic to detect the target and then deliver them. Wouldn’t it be nice to ship just one binary which work on all Macs (Intel and Apple Silicon based) We call this a Fat Binary.

Here is how you can do it:

Consider this short Go program:

Save this as main.go

package main

import "fmt"

func main() {
    fmt.Println("Fat Binary")
}

Now, you can build a binary for both the architecture like this:

GOOS=darwin GOARCH=arm64 go build -o mac_arm64 main.go GOOS=darwin GOARCH=amd64 go build -o mac_amd64 main.go

When you run this, you will see two binaries your folder:

ls
-rwxr-xr-x@ 1 vinitkumar  staff   2.1M Dec 18 18:00 mac_amd64
-rwxr-xr-x@ 1 vinitkumar  staff   2.1M Dec 18 18:00 mac_arm64

Alright, this looks decent, now how do we stitch them together to make a big fat binary that works on all Macs?

Enter Lipo. This utility can take two binaries and then spit out a far binary that works on all CPU architectures. On Mac, with command line tools installed it just available as lipo

So doing which lipo gives /usr/bin/lipo. On Ubuntu however, it comes bundles with llvm. So you need to do this:

sudo apt install llvm
# and then it is present as `llvm-lipo-14` depending on which llvm it is, for me it is llvm-14
So `/usr/bin/llvm-lipo-14'

Now, as we have located Lipo, now, we will use it to generate the fat binary.

# on Ubuntu
llvm-lipo-14 -create -output "mac_universal" "mac_arm64" "mac_amd64"
# on Mac
lipo -create -output "mac_universal" "main_arm64" "main_amd64"

Once created, we can verify if the binary is proper using the file util.

file mac_universal
mac_universal: Mach-O universal binary with 2 architectures: [x86_64:Mach-O 64-bit executable x86_64] [arm64]
mac_universal (for architecture x86_64):        Mach-O 64-bit executable x86_64
mac_universal (for architecture arm64): Mach-O 64-bit executable arm64

You can execute this on either of the CPUs and it would just work.

Bonus code

Here is code to generate the Ascii diagram above. You need to have Pillow installed though.

from PIL import Image, ImageDraw, ImageFont
import os

# Create a new image with white background
width = 800
height = 600
image = Image.new('RGB', (width, height), 'white')
draw = ImageDraw.Draw(image)

# Try to load a font (you may need to adjust the path)
try:
    font = ImageFont.truetype("Arial.ttf", 32)
except:
    font = ImageFont.load_default()

# Draw the outer rectangle
draw.rectangle([(50, 50), (width-50, height-50)], outline='black', width=2)

# Draw the vertical divider
draw.line([(width/2, 100), (width/2, 400)], fill='black', width=2)

# Draw the horizontal dividers
draw.line([(50, 250), (width-50, 250)], fill='black', width=2)
draw.line([(50, 400), (width-50, 400)], fill='black', width=2)

# Add text
draw.text((width/4, 150), "x86_64\nCode", font=font, fill='black', anchor="mm")
draw.text((3*width/4, 150), "ARM64\nCode", font=font, fill='black', anchor="mm")
draw.text((width/4, 325), "x86_64\nResources", font=font, fill='black', anchor="mm")
draw.text((3*width/4, 325), "ARM64\nResources", font=font, fill='black', anchor="mm")
draw.text((width/2, 450), "Shared Resources", font=font, fill='black', anchor="mm")
draw.text((width/2, 75), "Fat Binary", font=font, fill='black', anchor="mm")

# Save the image
image.save('fat_binary_diagram.png')

Building a Free Multi-Device Sync System for Obsidian with Git

Tue, 26 Nov 2024 00:00:00 GMT

I love making notes in Obsidian. It’s truly a Local-First Application. I love that it is free and doesn’t keep your content hostage. However, I many multiple Macs and keeping them in sync was becoming an issue. I didn’t wanted to use DropBox or Google Drive and thought why not just automated it myself with some line of code.

We only need few tools to implement:

crontab
shell script
a private github repo (any git repo where you can push works)

Create an empty private repo on Github and copy the SSH URl. Not initialize the local repo with git if it’s not already done.

git init
git remote add origin git@github.com:<username>/repo.git

Create a new file called as auto_commit_push.sh in your home directory.

The idea is to execute this script in frequent intervals using crontab.

This is how the script looks like:


# Set repository path - replace with your actual path
#REPO_PATH="/Users/vinitkumar/Documents/knowledge-base"
# add path to your own repo
REPO_PATH=""


cd "$REPO_PATH" || exit

git pull origin HEAD
git push origin HEAD
git add .
git commit -m "Auto commit and push on $(date '+%Y-%m-%d %H:%M:%S')"
git push origin HEAD

Here is how the crontab looks like, add it by executing this:

crontab -e

*/1 * * * * /bin/bash ~/auto_commit_push.sh >> ~/auto_commit_push.log 2>&1

IMPORTANT: None of this will work, if you don’t give full disk access to cron.

For this go to settings on Mac, and give full disk access by opening the settings, and add press cmd + shift + g and use /usr/sbin and then add cron to the full disk access.

Once done, you can also do the same in the other Mac and enjoy a free sync that just works, in secure.

Also, you might want to disable signing commits like this.

Go to the notes directory and disable signing commits just for this repo.

[commit]
	gpgsign = false

~~Also, add .obsidian to .gitignore so that you don’t get merge conflicts between multiple machines. All we care about notes files, and not the Obsidian configurations.~~

Actually, we should sync the whole folder because we want the plugin and settings sync as well which is stored in .obsidian folder.

.obsidian/*

However, if you can afford, I would suggest to buy a paid obsidian subscription for sync as it is a genuinely great software.

New Job at ScaleFusion

Mon, 18 Nov 2024 00:00:00 GMT

Reflecting on My Career Journey and a New Beginning at Scalefusion

I began my professional journey in February 2013 with a Dutch company based in Pune. As a fresh graduate, I was fortunate to find inspiring mentors like Jos, Ruben, and Jonathan, who shaped my early career. I also had the privilege of working alongside incredible teammates such as Aashish, Robert, Edwin, Pratik, and others who became lifelong friends.

During my time there, I worked on an ambitious project, SocialSchools, which became a cornerstone of my career. I contributed to the development of its first communication platform for schools and later led the effort to build a multi-tenant CMS from scratch. This platform powered thousands of domains and handled millions of monthly requests, marking a significant milestone for me and the team. In 2022, SocialSchools was acquired by KidsKonnect, and I continued contributing to their vision for the next two years.

A Turning Point and the Path Ahead

By October 2024, it became clear that my journey with KidsKonnect would come to an end. While contemplating my next steps, I reconnected with a company I’ve admired for years—Scalefusion. Known for its innovative products and leadership, it felt like a natural fit for the challenges I was eager to tackle. After a rewarding interview process, I was thrilled to accept the role of Principal Engineer.

Gratitude and Aspirations

Reflecting on nearly 12 years at my previous company, I am deeply grateful for the mentorship, skills, and friendships that shaped me. This experience has prepared me to embrace this next phase with confidence and ambition.

I would like to thank my wife, family, and colleagues for their unwavering support during this transition. At Scalefusion, I look forward to reinventing myself, embracing new challenges, and achieving greater heights alongside an incredible team.

Here’s to growth, learning, and making an impact!

Non Negotiables

Wed, 16 Oct 2024 00:00:00 GMT

I wrote this flying to Delhi a week before without internet/distractions on my journal. Here, I just porting it to the digital format, so that I can refer to it anytime. Or share it with someone who might find it useful.

Just like Carmy wrote on the series “The Bear”, about the non-negotiables, I want to write mine as a software artist. I say “Software Artist” because that is who I am at the core.

Study everything interesting around you.
Make mistakes, but only once.
Live your own life, don’t give any employer the charge of your life.
Don’t get blindsided by it.
If you don’t enjoy a party/company just leave.
Believe in yourself.
Eat your own dog food.
Create art everyday (Code/Music/Sketch/Write).
Write type or Dictate everyday.
Dream big without fear.
8 hrs of sleep (~min 6 hours everyday).
Set backs are sometimes part of life, don’t get bogged down by it.
Study deeply and learn.

Why Asking For Help Is A Crucial Skill

Fri, 30 Aug 2024 00:00:00 GMT

If you ever worked as a software engineer, chances are you must have gotten stuck in a problem that seemed super hard to solve. Also, if you work in sprints like setup, pretty much all your time for the next two weeks is booked already. What usually happens with these tricky issues is that, it would totally derail all your estimates and planning and you would seriously lag behind your tasks and might perform even poorly because of the mounting time pressure.

Here are some of my suggestions based on my personal experiences working in early stage startup:

This one trick was taught by my CEO at the time in 2013 was that if you can’t figure out head or tail of what to do with a problem, give it 30 mins of serious effort and ask for help.

Why is this such a great advice? Let me break it down for you.

Asking for help early on basically limits the amount of time that could be wasted because you are trying to figure out something for which you don’t have complete context/background knowledge. If you have more experience folks at work, they can always show you a correct path and you can then follow their advise and solve it with a much higher probability than earlier.
On the contrary, if you don’t ask for help and only ask the team sometime or some days later, you also put them under pressure as someone else needs to do that task in place of you albeit with more time pressure.
All setup related issues should be immediately brought to attention of the platform/Ops/Senior developers. A good reproducible working environment is a must with any productive company.
However, this doesn’t mean that you run for cover every time you face a problem. You should definitely try to think about a solution and write it in a written format, then discuss your approach without writing a single line of code. The good thing about this approach is that your peers will see that you have put some effort into the problem, and discussing potential solutions also gives them an opportunity to improve your high-level design and suggest improvements.
This is also the culture that one should teach newer/junior devs so that it becomes more of a cultural thing with the dev team.
You don’t have to suffer because of a hard problem/setup issue mostly because you are not asking for help because of your EGO. EGO has no place in a collaborative environment. It’s good to know what you don’t know so that you can ask help and be better at it.
Another important thing to note here is that one should try not to ask for the same advice twice. Let me explain:

Say you had a Docker issue, and you ask your senior for help and they solve your problem. It’s your duty to make a note or video recording of the help, so that if you face that problem once again, you can solve it on your own next time. This saves time for everyone involved. Anyone will get annoyed if you get stuck with the same problem and don’t take notes of the solution, and keep coming back with the same issue. Making notes of the solution is a great approach and it shows how much you respect others’ time.

Hope these tips would help you become a better developer and an asset to the team.

Why Asking For Help Is A Crucial Skill

Fri, 30 Aug 2024 00:00:00 GMT

Monthly Review

Tue, 13 Aug 2024 00:00:00 GMT

This past month has been quite interesting. Work-wise, it was decent—some good moments and some not-so-great ones. We switched back to a more structured way of working after trying out something new. While many people might dislike Scrum for good reasons (like all the meetings), it does bring some order to the chaos. The alternative we tried was even messier.

On a personal note, my wife and I have managed to keep up a fairly consistent routine of walking five days a week, except when one of us is sick. However, our sleep quality and duration are still a concern. We always end up going to bed late and waking up early, so sometimes we need to make up for it with an afternoon nap. We’ll try to improve this in the coming months.

Financially, our expenses have increased a bit, and we need to get them under control. We’re not in a bad shape, but we need to be more careful and frugal. I’ve also been struggling with motivation, which has been a persistent worry. I’m trying to cut motivation out of the equation altogether since it’s proven to be an unreliable ally.

On a lighter note, we watched “Deadpool and Wolverine” movie recently, and it was a lot of fun.

My guitar skills are improving, and I hope to be able to play some decent songs—both chords and solos—in the coming months.

One thing I really want to focus on is reading and writing more. I have a great collection of books, but I just can’t seem to find the time to read them. I’m thinking I should start by reading a few pages a day and see how it goes. I also need to seriously cut down on social media use. It’s such a time-waster and always leaves me feeling bad.

Here are some screenshots of the last month walking and sleep data:

Optimizing ZSH Performance: A Guide to Profiling and Fixing Shell Slowness

Tue, 02 Jul 2024 00:00:00 GMT

Lately, my shell (zsh) feels slow to use. Even booting it for the first time feels like it is slow to render. It shouldn’t happen as I am using a beefy MacBook Pro. I also don’t don’t use any other zsh plugin other than git. So, I decided to investigate what is causing the slowness.

A quick search on the internet led me to the zsh profiling feature. I can profile the shell using this:

Put the following code at the start and end of your .zshrc file:

zmodload zsh/zprof
# your zshrc file content here.
zprof

Save it and source the ~/.zshrc file. Now, you can see the profiling output by running zprof.


num  calls                time                       self            name
-----------------------------------------------------------------------------------
 1)    1        3886.43  3886.43   93.04%   3348.16  3348.16   80.15%  compinit
 2)  831         381.00     0.46    9.12%    381.00     0.46    9.12%  compdef
 3)    2         169.68    84.84    4.06%     98.30    49.15    2.35%  nvm
 4)    1          86.15    86.15    2.06%     86.15    86.15    2.06%  compdump
 5)    2          71.57    35.78    1.71%     71.57    35.78    1.71%  compaudit
 6)   22          77.67     3.53    1.86%     58.00     2.64    1.39%  _omz_source
 7)    1          62.61    62.61    1.50%     54.07    54.07    1.29%  nvm_ensure_version_installed
 8)    1         209.63   209.63    5.02%     39.95    39.95    0.96%  nvm_auto
 9)    1           8.54     8.54    0.20%      8.54     8.54    0.20%  nvm_is_version_installed
10)    1           8.33     8.33    0.20%      8.02     8.02    0.19%  nvm_die_on_prefix
11)    1           6.24     6.24    0.15%      6.24     6.24    0.15%  regexp-replace
12)    4           3.69     0.92    0.09%      3.69     0.92    0.09%  add-zsh-hook
13)    1           3.62     3.62    0.09%      3.62     3.62    0.09%  colors
14)    6           3.57     0.59    0.09%      3.57     0.59    0.09%  is-at-least
15)    1           2.99     2.99    0.07%      2.99     2.99    0.07%  zrecompile
16)    1           2.12     2.12    0.05%      2.12     2.12    0.05%  test-ls-args
17)    1           0.44     0.44    0.01%      0.44     0.44    0.01%  nvm_has
18)    2           0.31     0.16    0.01%      0.31     0.16    0.01%  is_plugin
19)    4           0.31     0.08    0.01%      0.31     0.08    0.01%  nvm_npmrc_bad_news_bears
20)    1           0.08     0.08    0.00%      0.04     0.04    0.00%  complete
21)    3           0.04     0.01    0.00%      0.04     0.01    0.00%  is_theme
22)    2           0.02     0.01    0.00%      0.02     0.01    0.00%  bashcompinit
23)    2           0.02     0.01    0.00%      0.02     0.01    0.00%  env_default
24)    1         209.65   209.65    5.02%      0.02     0.02    0.00%  nvm_process_parameters
25)    1           0.01     0.01    0.00%      0.01     0.01    0.00%  nvm_is_zsh

-----------------------------------------------------------------------------------

 1)    1        3886.43  3886.43   93.04%   3348.16  3348.16   80.15%  compinit
       1/2        71.57    71.57    1.71%      0.28     0.28             compaudit [5]
       1/1        86.15    86.15    2.06%     86.15    86.15             compdump [4]
     818/831     380.55     0.47    9.11%    380.55     0.47             compdef [2]

-----------------------------------------------------------------------------------

     818/831     380.55     0.47    9.11%    380.55     0.47             compinit [1]
      12/831       0.41     0.03    0.01%      0.41     0.03             _omz_source [6]
       1/831       0.04     0.04    0.00%      0.04     0.04             complete [20]
 2)  831         381.00     0.46    9.12%    381.00     0.46    9.12%  compdef

-----------------------------------------------------------------------------------

24)    1         209.65   209.65    5.02%      0.02     0.02    0.00%  nvm_process_parameters
       1/1       209.63   209.63    5.02%     39.95    39.95             nvm_auto [8]

-----------------------------------------------------------------------------------

       1/1       209.63   209.63    5.02%     39.95    39.95             nvm_process_parameters [24]
 8)    1         209.63   209.63    5.02%     39.95    39.95    0.96%  nvm_auto
       1/2       169.68   169.68    4.06%      4.92     4.92             nvm [3]

-----------------------------------------------------------------------------------

       1/2       169.68   169.68    4.06%      4.92     4.92             nvm_auto [8]
       1/2       164.76   164.76    3.94%     93.38    93.38             nvm [3]
 3)    2         169.68    84.84    4.06%     98.30    49.15    2.35%  nvm
       1/1         0.44     0.44    0.01%      0.44     0.44             nvm_has [17]
       1/1         8.33     8.33    0.20%      8.02     8.02             nvm_die_on_prefix [10]
       1/1        62.61    62.61    1.50%     54.07    54.07             nvm_ensure_version_installed [7]
       1/2       164.76   164.76    3.94%     93.38    93.38             nvm [3]

-----------------------------------------------------------------------------------

       1/1        86.15    86.15    2.06%     86.15    86.15             compinit [1]
 4)    1          86.15    86.15    2.06%     86.15    86.15    2.06%  compdump

-----------------------------------------------------------------------------------

 6)   22          77.67     3.53    1.86%     58.00     2.64    1.39%  _omz_source
       1/2         0.01     0.01    0.00%      0.01     0.01             bashcompinit [22]
       2/2         0.02     0.01    0.00%      0.02     0.01             env_default [23]
      12/831       0.41     0.03    0.01%      0.41     0.03             compdef [2]
       1/1         2.12     2.12    0.05%      2.12     2.12             test-ls-args [16]
       6/6         3.57     0.59    0.09%      3.57     0.59             is-at-least [14]
       1/1         3.62     3.62    0.09%      3.62     3.62             colors [13]
       4/4         3.69     0.92    0.09%      3.69     0.92             add-zsh-hook [12]
       1/1         6.24     6.24    0.15%      6.24     6.24             regexp-replace [11]

-----------------------------------------------------------------------------------

       1/2        71.57    71.57    1.71%      0.28     0.28             compinit [1]
       1/2        71.29    71.29    1.71%     71.29    71.29             compaudit [5]
 5)    2          71.57    35.78    1.71%     71.57    35.78    1.71%  compaudit
       1/2        71.29    71.29    1.71%     71.29    71.29             compaudit [5]

-----------------------------------------------------------------------------------

       1/1        62.61    62.61    1.50%     54.07    54.07             nvm [3]
 7)    1          62.61    62.61    1.50%     54.07    54.07    1.29%  nvm_ensure_version_installed
       1/1         8.54     8.54    0.20%      8.54     8.54             nvm_is_version_installed [9]

-----------------------------------------------------------------------------------

       1/1         8.54     8.54    0.20%      8.54     8.54             nvm_ensure_version_installed [7]
 9)    1           8.54     8.54    0.20%      8.54     8.54    0.20%  nvm_is_version_installed

-----------------------------------------------------------------------------------

       1/1         8.33     8.33    0.20%      8.02     8.02             nvm [3]
10)    1           8.33     8.33    0.20%      8.02     8.02    0.19%  nvm_die_on_prefix
       4/4         0.31     0.08    0.01%      0.31     0.08             nvm_npmrc_bad_news_bears [19]

-----------------------------------------------------------------------------------

       1/1         6.24     6.24    0.15%      6.24     6.24             _omz_source [6]
11)    1           6.24     6.24    0.15%      6.24     6.24    0.15%  regexp-replace

-----------------------------------------------------------------------------------

       4/4         3.69     0.92    0.09%      3.69     0.92             _omz_source [6]
12)    4           3.69     0.92    0.09%      3.69     0.92    0.09%  add-zsh-hook

-----------------------------------------------------------------------------------

       1/1         3.62     3.62    0.09%      3.62     3.62             _omz_source [6]
13)    1           3.62     3.62    0.09%      3.62     3.62    0.09%  colors

-----------------------------------------------------------------------------------

       6/6         3.57     0.59    0.09%      3.57     0.59             _omz_source [6]
14)    6           3.57     0.59    0.09%      3.57     0.59    0.09%  is-at-least

-----------------------------------------------------------------------------------

15)    1           2.99     2.99    0.07%      2.99     2.99    0.07%  zrecompile

-----------------------------------------------------------------------------------

       1/1         2.12     2.12    0.05%      2.12     2.12             _omz_source [6]
16)    1           2.12     2.12    0.05%      2.12     2.12    0.05%  test-ls-args

-----------------------------------------------------------------------------------

       1/1         0.44     0.44    0.01%      0.44     0.44             nvm [3]
17)    1           0.44     0.44    0.01%      0.44     0.44    0.01%  nvm_has

-----------------------------------------------------------------------------------

18)    2           0.31     0.16    0.01%      0.31     0.16    0.01%  is_plugin

-----------------------------------------------------------------------------------

       4/4         0.31     0.08    0.01%      0.31     0.08             nvm_die_on_prefix [10]
19)    4           0.31     0.08    0.01%      0.31     0.08    0.01%  nvm_npmrc_bad_news_bears

-----------------------------------------------------------------------------------

20)    1           0.08     0.08    0.00%      0.04     0.04    0.00%  complete
       1/831       0.04     0.04    0.00%      0.04     0.04             compdef [2]

-----------------------------------------------------------------------------------

21)    3           0.04     0.01    0.00%      0.04     0.01    0.00%  is_theme

-----------------------------------------------------------------------------------

       1/2         0.01     0.01    0.00%      0.01     0.01             _omz_source [6]
22)    2           0.02     0.01    0.00%      0.02     0.01    0.00%  bashcompinit

-----------------------------------------------------------------------------------

       2/2         0.02     0.01    0.00%      0.02     0.01             _omz_source [6]
23)    2           0.02     0.01    0.00%      0.02     0.01    0.00%  env_default

-----------------------------------------------------------------------------------

25)    1           0.01     0.01    0.00%      0.01     0.01    0.00%  nvm_is_zsh

If notice the output you would see the nvm showing prominently in it. It means it’s the reason for the slowness.

Here is my ~/.zshrc file for reference:

# If you come from bash you might have to change your $PATH.
# export PATH=$HOME/bin:/usr/local/bin:$PATH

# Path to your oh-my-zsh installation.
export ZSH="$HOME/.oh-my-zsh"

# Set name of the theme to load --- if set to "random", it will
# load a random theme each time oh-my-zsh is loaded, in which case,
# to know which specific one was loaded, run: echo $RANDOM_THEME
# See https://github.com/ohmyzsh/ohmyzsh/wiki/Themes
ZSH_THEME="robbyrussell"

# Set list of themes to pick from when loading at random
# Setting this variable when ZSH_THEME=random will cause zsh to load
# a theme from this variable instead of looking in $ZSH/themes/
# If set to an empty array, this variable will have no effect.
# ZSH_THEME_RANDOM_CANDIDATES=( "robbyrussell" "agnoster" )

# Uncomment the following line to use case-sensitive completion.
# CASE_SENSITIVE="true"

# Uncomment the following line to use hyphen-insensitive completion.
# Case-sensitive completion must be off. _ and - will be interchangeable.
# HYPHEN_INSENSITIVE="true"

# Uncomment one of the following lines to change the auto-update behavior
# zstyle ':omz:update' mode disabled  # disable automatic updates
# zstyle ':omz:update' mode auto      # update automatically without asking
# zstyle ':omz:update' mode reminder  # just remind me to update when it's time

# Uncomment the following line to change how often to auto-update (in days).
# zstyle ':omz:update' frequency 13

# Uncomment the following line if pasting URLs and other text is messed up.
# DISABLE_MAGIC_FUNCTIONS="true"

# Uncomment the following line to disable colors in ls.
# DISABLE_LS_COLORS="true"

# Uncomment the following line to disable auto-setting terminal title.
# DISABLE_AUTO_TITLE="true"

# Uncomment the following line to enable command auto-correction.
# ENABLE_CORRECTION="true"

# Uncomment the following line to display red dots whilst waiting for completion.
# You can also set it to another string to have that shown instead of the default red dots.
# e.g. COMPLETION_WAITING_DOTS="%F{yellow}waiting...%f"
# Caution: this setting can cause issues with multiline prompts in zsh < 5.7.1 (see #5765)
# COMPLETION_WAITING_DOTS="true"

# Uncomment the following line if you want to disable marking untracked files
# under VCS as dirty. This makes repository status check for large repositories
# much, much faster.
# DISABLE_UNTRACKED_FILES_DIRTY="true"

# Uncomment the following line if you want to change the command execution time
# stamp shown in the history command output.
# You can set one of the optional three formats:
# "mm/dd/yyyy"|"dd.mm.yyyy"|"yyyy-mm-dd"
# or set a custom format using the strftime function format specifications,
# see 'man strftime' for details.
# HIST_STAMPS="mm/dd/yyyy"

# Would you like to use another custom folder than $ZSH/custom?
# ZSH_CUSTOM=/path/to/new-custom-folder

# Which plugins would you like to load?
# Standard plugins can be found in $ZSH/plugins/
# Custom plugins may be added to $ZSH_CUSTOM/plugins/
# Example format: plugins=(rails git textmate ruby lighthouse)
# Add wisely, as too many plugins slow down shell startup.
plugins=(git)
alias c='clear'
alias activate='source venv/bin/activate'
alias syncall='gco develop && ggpull && gco staging && ggpull && gco master && ggpull'
alias vim="nvim"
alias vi="nvim"
alias v="nvim"

source $ZSH/oh-my-zsh.sh

# User configuration

# export MANPATH="/usr/local/man:$MANPATH"

# You may need to manually set your language environment
# export LANG=en_US.UTF-8

# Preferred editor for local and remote sessions
if [[ -n $SSH_CONNECTION ]]; then
  export EDITOR='vim'
else
  export EDITOR='mvim'
fi

# Compilation flags
# export ARCHFLAGS="-arch x86_64"

# Set personal aliases, overriding those provided by oh-my-zsh libs,
# plugins, and themes. Aliases can be placed here, though oh-my-zsh
# users are encouraged to define aliases within the ZSH_CUSTOM folder.
# For a full list of active aliases, run `alias`.
#
# Example aliases
# alias zshconfig="mate ~/.zshrc"
# alias ohmyzsh="mate ~/.oh-my-zsh"

eval "$(zoxide init zsh)"
. "$HOME/.cargo/env"
export PATH="/opt/homebrew/opt/ruby/bin:$PATH"
[ -f ~/.fzf.zsh ] && source ~/.fzf.zsh

# export NVM_DIR="$HOME/.nvm"
# [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
# [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion

Now, NVM is an useful tool, but it doesn’t need to be enabled all the time for my day to day development. So, I decided to just comment nvm for now and uncomment it as and when needed.

~Fin

Finally, my shell is back to normal speed. I hope this helps you too.

New Week Start

Mon, 01 Jul 2024 00:00:00 GMT

Starting a new work week today. It’s exciting to start the week with a bang. I have a lot of things to do this week. I have to finish the work on the new feature that I have been working on for the past 2 weeks.

I also got a new Guitar this weekend. I am excited to learn how to play it. I have been watching a lot of YouTube videos on how to play the guitar. I am excited to learn how to play the guitar. I have always wanted to learn how to play the guitar. I am excited to start this new journey. I also got a new Guitar teacher at the same music school where my kiddo goes to learn Piano. Always wanted to learn it, but can’t afford it when I was in college.

I got a new wireless earphones last weekend as well. It’s nice and comes with noise canceling as well. I also have an Audio Technica Headphones, but it is painful to wear with glasses. I will still use them but not while long work calls.

I also want to write more and more and get that part of my brain reactivated. I also want to read many books I got. I have a lot of things to do this week. I am excited to start this new week.

I am also working on my mindset. I want me to be more positive and grateful. I also want to be more focused towards my goal and meet my purpose.

I also started watching “The Bear - Season 3” on Disney+ Hotstar. It’s a nice show. The third season is also nice. I am excited to watch the rest of the season.

At this point, these things are main goals for me:

Complete the work on the features and bug I need to do.
Learn Guitar and practice everyday.
Write more and more and get that part of my brain reactivated.
Spend more quality time with my family.

~Fin

Weekly Review (24-28 June 2024)

Fri, 28 Jun 2024 00:00:00 GMT

I have been struggling fairly with the blog. I don’t write that often. I love writing and reading, but lately, I have not been to do either.

Coming to the topic. The week started with me waking up at 5am every day. My kiddo started Grade-1 and we need to wake up, and get him ready for school and drop him to school. After that, my wife and I go for a walk. We are doing this pretty regularly for some weeks and it feels good.

The only thing that’s bad in this is what we go to sleep fairly late (Never before 12.30am), and wake up early, so we both are sleep deprived. Now to compensate the sleep loss, we tend to get a quick nap after our walk. This is not good, but we are trying to get to bed early. In a perfect world, I would always like to have a 8hr sleep, but that’s not possible with the current schedule.

Life at work has been moderately stressful as well. I am working on a newer stack and there is insane amount of code and business rules to understand. I think I am handling it fairly well, but it’s always humbling working on something new and realizing how much you don’t know. It’s also a project with DDD (Domain Driven Development) and I am trying to understand the concepts and apply them. It’s a good learning experience. Great thing about the project is an insane amount of test coverage and that gives me a lot of confidence in making changes. Also, my local setup has issues, so only way I can make sure my code works is by running the tests and writing them. I have done most amount of TDD in my life in the last 1 year and I get the appeal, especially when you are working on a complex system and with many other people.

I also got a couple of new books last week and I will try to read them this weekend and make some notes. I have so many great books at home and if I am able to make strides with them, I will definitely be able to achieve much more in life.

I also have been thinking about my blog and how I can make it better. I have been thinking about writing more and more and I think I will be able to do it. I have been thinking about writing about my work, and even small things that I learnt daily. The blog is just for me and me alone.

That’s it folks. Hoping to write more content like this in future. Til then, have a good weekend.


o   ^__^
 o  (oo)\_______
    (__)\       )\/\
        ||----w |
        ||     ||

Favorite Coding Fonts in 2024

Mon, 24 Jun 2024 00:00:00 GMT

I think every programmer who loves their craft must love one font or another and I am no exception. I have always been fascinated by the beauty of fonts and the way they can make or break a design. I have always been a fan of monospaced fonts and I have tried a lot of them over the years.

Here are some of my favorite monospaced fonts that I have used over the years:

I tried to make screenshots of these fonts in my terminal (Ghostty), with vim and rendering the same piece of code.

Source Code Pro

It is pretty much my all time favorite font. I always keep coming back to it and many programmers who I respect also use it even to date. It is a very readable font and it looks great on any screen.

Inconsolata (G)

I love this font. It is simple, not frills and reads great on any screen. It is one of a classic monospaced font that I have used over the years.

JetBrains Mono

Relatively new font and I didn’t liked it in the beginning, but have learned to love it over time. It is a very readable font and looks great on any screen.

IBM Plex Mono

It is my current favorite font. It is very nicely designed and I would recommend it to anyone looking for a new great font.

Cascadia Code

A good font from Microsoft. It is a very readable font and looks great on any screen but I don’t use it much.

Go mono

I love this font as well. Simple yet, very nice font to keep you in the zone.

Iosevka

Relatively new font, but great. In the same league as IBM Plex Mono and JetBrains Mono. I would recommend it to anyone looking for a new great font. It’s relatively thin font though so might not be everyone’s cup of tea.

Victor Mono

I used this font for some months too. It’s good and I might revisit it in future.

SF Mono

Apple’s font. It is a very readable font and looks great on any screen. Some people love it, some don’t. I am in the former camp.

Learning is Important

Mon, 17 Jun 2024 00:00:00 GMT

I have been in a bit of stagnancy these days. Things has not been smooth, health has been not that great either. My mental health health has been a bit off too. I have been unhappy and moody of late and I really, really don’t like this version of me.

I think reading books and keeping my mind busy always helped. I have been very bad at time management and that has caused majority of my problems. When to work and when to take a good break is an art I have have not mastered yet.

But I am not a person who gives up easily. So I am working actively on myself and want to get happier, and enjoy my life and work more.

Here are a couple of new books my son gifted me on this “Fathers Day”. I love my kiddo more than anything else in this world.

Fire in my belly

Fri, 10 May 2024 00:00:00 GMT

I have a fire in my belly. I am ready to take on new challenges. I have been working on my skills and I am ready to put them to the test.

It’s very easy to live like a recluse, but I am ready to step out of my comfort zone and take on the world.

A lot of hardships that I faced in the past, has been mostly because of me. I have been my own worst enemy. But not anymore. I am ready to take on the world and make a difference.

I have not been eating well, sleeping well and even working out. But I am ready to change that. I am ready to take care of myself and be the best version of myself.

I also want to write more and share my thoughts with the world. I have been holding back for too long. But not anymore. I am ready to share my thoughts and ideas with the world. This is a promise from me to by future self. I want to be well for me and my family.

That’s it for now. And I hope my readers are doing well. Take care and stay safe.

Leveling Up With Gary Bernhardt's Destroyallsoftware Series

Mon, 31 Jul 2023 00:00:00 GMT

Introduction:

I believe that continuous learning and practice are key to staying ahead in the ever-evolving world of software development. Recently, I stumbled upon an exceptional resource that has been highly recommended by many experienced programmers – Gary Bernhardt’s “destroyallsoftware” series. In this blog, I will share my experience diving into this series and how it has helped me strengthen my coding fundamentals. To illustrate my journey, I will focus on a specific project I worked on from the “from-scratch” repository and discuss the valuable insights gained from this process.

Gary Bernhardt and His destroyallsoftware Series:

Gary Bernhardt is a renowned programmer and educator who has gained a strong following for his in-depth and well-crafted educational content. The “destroyallsoftware” series is one of his most notable contributions to the programming community. The series covers a wide range of topics, including software design, testing, debugging, and performance optimization. Gary’s teaching style is engaging and enlightening, making complex concepts accessible to learners at various skill levels.

Investing in My Learning Journey:

Recognizing the significance of strengthening my coding basics, I decided to dedicate some focused time to learning from the “destroyallsoftware” series. My plan was simple: pick one of Gary’s videos and follow along, actively coding alongside him. To track my progress and share my work with others, I created a repository on GitHub: https://github.com/vinitkumar/from-scratch.

The “from-scratch” repository houses various projects, each designed to teach the fundamentals of a specific programming concept. For this blog, I chose the “malloc-from-scratch” project (https://github.com/vinitkumar/from-scratch/tree/main/malloc-from-scratch). This project aims to implement a basic memory allocation mechanism from scratch, an essential skill for any programmer.

My Weekly Learning Routine:

I decided to challenge myself and set a goal of completing one project from the “from-scratch” repository every week. This schedule allowed me to delve deeply into each topic while maintaining a sustainable learning pace. I believed that the combination of guided learning from Gary’s videos and hands-on coding practice would be the most effective way to solidify my understanding of core concepts.

The malloc-from-scratch Project:

With excitement and determination, I began working on the “malloc-from-scratch” project. The task involved implementing a simplified version of the malloc function, which dynamically allocates memory during program execution. Though it seemed daunting at first, Gary’s video provided a clear and concise breakdown of the process, making it less intimidating.

I followed along with Gary, typing out the code as he explained each step. While coding, I encountered some challenges, but I found that these obstacles were valuable learning opportunities. They forced me to think critically, debug, and understand the underlying mechanisms better. Additionally, the satisfaction of seeing my code work correctly was immensely rewarding.

Key Insights and Takeaways:

As I progressed through the project, I gained several essential insights and takeaways:

Understanding Memory Allocation: Implementing malloc from scratch deepened my understanding of memory allocation and management. I learned about the heap, memory fragmentation, and the importance of pointer arithmetic.
Debugging Skills: During the coding process, I faced bugs and logical errors. Debugging these issues sharpened my troubleshooting abilities and taught me to use tools like GDB effectively.
Software Design Principles: Gary’s approach to software design emphasized simplicity, readability, and modularity. These principles have influenced the way I approach coding, leading to more maintainable and scalable code.
Appreciation for Standard Libraries: Creating a memory allocator from scratch made me appreciate the robustness and complexity of standard libraries. It also helped me comprehend the necessity of these foundational components in any programming language.
Confidence in Coding: Tackling challenging projects alongside an experienced instructor gave me confidence in my coding skills. I realized that with determination and the right resources, I could tackle complex problems.

Keeping the Momentum Going:

Having completed the “malloc-from-scratch” project, I am motivated to continue my weekly learning routine. The experience of learning from Gary Bernhardt’s “destroyallsoftware” series has been transformative for my programming journey. Each week, I look forward to selecting a new project and delving into exciting and diverse programming concepts.

Conclusion:

Gary Bernhardt’s “destroyallsoftware” series has proven to be an invaluable resource for my coding education. The combination of guided learning through videos and hands-on coding practice has helped me strengthen my foundational knowledge and hone my programming skills.

I would highly recommend Gary’s series to anyone looking to level up their coding skills, whether you are a beginner seeking a solid foundation or an experienced developer striving for continuous improvement. Investing time in learning from Gary Bernhardt is a worthwhile endeavor that will undoubtedly pay dividends in your programming journey. I am excited to continue my weekly learning routine and explore more of the “destroyallsoftware” series, as I strive to become a better programmer each day.

The Changing Landscape of Free Online Services and Open-Source Software

Tue, 04 Jul 2023 00:00:00 GMT

Introduction:

In the past decade, the online world experienced a paradigm shift in the availability of free services. Websites and platforms that once offered generous free options, such as Flickr’s 1TB of storage or Google Photos’ unlimited high-resolution uploads, have either transitioned to paid models or completely withdrawn their free offerings. This transformation has disrupted users’ expectations and raised concerns about the future of freely accessible online services and open-source software.

Current Issues and their possible solutions?

As technology advances and the costs of maintaining these services rise, companies are forced to reevaluate their business models. The harsh reality is that the days of receiving a “free lunch” online are gradually coming to an end. This shift prompts a reflection on the consequences it has for both users and developers, as well as the strategies employed to fund open-source projects.

The End of Free Lunch: The current reality is that the era of free online services is coming to an end. Previously, users could enjoy services like Flickr, offering 1TB of free storage, or Google Photos with unlimited high-resolution uploads. However, these platforms have now transitioned to paid models or discontinued their free offerings altogether.
Bait and Switch: A common practice among companies is the bait and switch tactic. This is particularly prevalent in the open-source software (OSS) community, where projects start as free and open-source but later shift to enterprise or paid licenses. This transition often leaves the community feeling betrayed and uncertain about the future of the software they rely on.
Problems with OSS Funding Strategies: Many OSS funding strategies are currently insufficient. Developers cannot continue to share their code for free without adequate compensation in the long run. It is only fair for OSS users to feel cheated when the license terms change unexpectedly.
Treating OSS as Technical Debt: When utilizing an OSS library, it is essential to view it as a form of technical debt rather than free labor. Recognizing the value provided by these libraries can help users understand the need for fair compensation and support for the creators and contributors.
Contributing and Affordability: To mitigate disappointment and ensure the sustainability of OSS, users are encouraged to contribute financially to the creators or contributors whenever possible. Alternatively, users can seek licenses that align with their financial capabilities. This approach offers a more reasonable way to navigate the evolving landscape of paid and open-source software.
Shifting Paradigm: As the economy and the world change, the funding model for OSS is likely to transform significantly. The days of venture capital-funded OSS projects may be over, giving way to a more profit-driven mindset where money plays a crucial role. This shift highlights the need for users and developers to adapt to the new realities of the industry.

Conclusion:

In conclusion, the evolving landscape of free online services and open-source software demands a proactive approach from users and developers. The days of taking these services for granted are fading, requiring a new mindset and awareness of the changing economic realities. As users, we must acknowledge the value provided by open-source projects and be willing to contribute financially to their sustainability. This support can help ensure that developers are fairly compensated for their efforts and can continue to improve and maintain the software we rely on.

Similarly, developers and project maintainers must explore innovative funding strategies that strike a balance between sustainability and accessibility. While the transition to paid models may be necessary, it is vital to consider the needs and expectations of the community, ensuring that the transition is transparent and fair.

In this evolving landscape, it is essential to foster a collaborative ecosystem where users, developers, and companies work together to sustain open-source projects. By embracing these changes, we can navigate the challenges ahead, ensuring the availability of high-quality software and services while recognizing the value and effort invested by creators and contributors.

Ultimately, the end of the “free lunch” era signifies a shift towards a more profit-driven model. However, it also presents an opportunity to establish new frameworks for collaboration, compensation, and open-source sustainability. By adapting to these changes, we can shape a future where innovation and accessibility coexist, ensuring that the online world continues to thrive for years to come.

The Changing Landscape of Free Online Services and Open-Source Software

Tue, 04 Jul 2023 00:00:00 GMT

Introduction:

Current Issues and their possible solutions?

The End of Free Lunch: The current reality is that the era of free online services is coming to an end. Previously, users could enjoy services like Flickr, offering 1TB of free storage, or Google Photos with unlimited high-resolution uploads. However, these platforms have now transitioned to paid models or discontinued their free offerings altogether.
Bait and Switch: A common practice among companies is the bait and switch tactic. This is particularly prevalent in the open-source software (OSS) community, where projects start as free and open-source but later shift to enterprise or paid licenses. This transition often leaves the community feeling betrayed and uncertain about the future of the software they rely on.
Problems with OSS Funding Strategies: Many OSS funding strategies are currently insufficient. Developers cannot continue to share their code for free without adequate compensation in the long run. It is only fair for OSS users to feel cheated when the license terms change unexpectedly.
Treating OSS as Technical Debt: When utilizing an OSS library, it is essential to view it as a form of technical debt rather than free labor. Recognizing the value provided by these libraries can help users understand the need for fair compensation and support for the creators and contributors.
Contributing and Affordability: To mitigate disappointment and ensure the sustainability of OSS, users are encouraged to contribute financially to the creators or contributors whenever possible. Alternatively, users can seek licenses that align with their financial capabilities. This approach offers a more reasonable way to navigate the evolving landscape of paid and open-source software.
Shifting Paradigm: As the economy and the world change, the funding model for OSS is likely to transform significantly. The days of venture capital-funded OSS projects may be over, giving way to a more profit-driven mindset where money plays a crucial role. This shift highlights the need for users and developers to adapt to the new realities of the industry.

Conclusion:

Building Large Technical Projects: Lessons from HashiCorp's Co-Founder

Fri, 02 Jun 2023 00:00:00 GMT

Mitchell Hashimoto is one programmer I really admire and he has been insanely productive and influential programmer for this last decade. He co-founded Hashicorp and has written Vagrant, Terraform, Consul and many other useful developer tools.

He just wrote My Approach to Building Large Technical Projects on his blog. Here he basically talks about his process of building non-trivial software that might span months and months of hard work. He gives some very nice tips about how to approach such tasks and succeed in finishing them.

I really like these tips and I wanted to note down some actionable items based on what he wrote. These tips are something we can incorportate in our daily routine.

Break down large tasks: When faced with a large project or task, break it down into smaller, more manageable chunks. This will allow you to see tangible progress and stay motivated throughout the project.
Focus on real results: Instead of solely focusing on the end goal, prioritize tasks that yield real results. Look for opportunities to create demos or prototypes that showcase the functionality you’re working on. This will give you a sense of accomplishment and help you gauge the success of your work.
Start with a feasible sub-project: Choose a sub-project within the larger task that is realistic and can yield visible outcomes. By starting with something achievable, you can build momentum and maintain your enthusiasm. Examples could include implementing a specific feature, setting up a basic framework, or creating a simple prototype.
Utilize automated testing: Incorporate automated testing, such as unit tests, early in the development process. This allows you to run your code and see it working, providing tangible feedback and boosting your confidence.
Aim for regular demos: Strive to build and showcase demos of your progress regularly. These demos don’t have to be fully polished or complete; they should be functional enough to demonstrate the key aspects of your project. Regular demos provide valuable feedback and help you evaluate the feasibility and quality of your work.
Don’t pursue perfection at first: Avoid getting caught up in perfectionism during the initial stages of your project. Instead, focus on creating a “good enough” version that allows you to move forward and demonstrate progress. You can always iterate and improve upon it later.
Build for yourself initially: When working on personal projects, prioritize solving problems or building functionality that you personally need. By addressing your own needs and experiences, you’ll likely stay more motivated and engaged in the development process. This also increases the likelihood of creating a useful product for others.
Incremental improvements and iterations: After reaching a demo stage, don’t stop there. Continuously iterate on the different components of your project, addressing areas that need improvement and adding new features gradually. This iterative process helps you refine and enhance your work over time.

Migrating to Neovim: A Developer's Guide to Modern Editor Configuration

Wed, 24 May 2023 00:00:00 GMT

Vim has long been a popular choice for developers and power users as a highly customizable and efficient text editor. However, in recent years, Neovim has emerged as a promising alternative to Vim, offering improved performance, enhanced features, and better extensibility. If you’re considering making the switch from Vim to Neovim, this blog post will guide you through the process and highlight the benefits of using Neovim.

What is Neovim?

Neovim is a modern fork of Vim that aims to improve upon Vim’s limitations while preserving its core principles and functionalities. Neovim maintains backward compatibility with Vim, meaning your existing Vim configuration and plugins should work seamlessly in Neovim with little to no modifications.

Why switch to Neovim?

There are several reasons why you might consider switching from Vim to Neovim:

Performance: Neovim is built with a strong focus on performance, offering faster startup times and smoother editing experience compared to Vim. Neovim’s architecture allows for better parallelism and asynchronous processing, resulting in improved responsiveness and reduced latency.
Enhanced features: Neovim introduces several new features and improvements over Vim. Some notable features include built-in terminal emulation, support for floating windows and pop-ups, better job control, and a revamped API for plugin development.
Better extensibility: Neovim provides a more powerful and flexible plugin architecture, making it easier to develop and maintain plugins. Neovim’s API offers enhanced scripting capabilities and better integration with modern tools and language servers.

Migrating your Vim configuration to Neovim

Migrating your Vim configuration to Neovim is a straightforward process, thanks to their high level of compatibility. Here are the steps to get started:

Install Neovim: Visit the Neovim website (https://neovim.io/) and follow the installation instructions for your operating system.
Copy your Vim configuration: Neovim uses the same configuration file format as Vim. Locate your .vimrc file and copy it to Neovim’s configuration directory. In the case of Neovim, the configuration file is typically located at ~/.config/nvim/init.vim.
Install plugins: Neovim supports the same plugin manager as Vim, such as Vundle, Pathogen, or vim-plug. Install your preferred plugin manager and use it to install the plugins you were using in Vim. In your Neovim configuration file, make sure to include the necessary plugin manager setup and plugin configurations.
Update plugin-specific configurations: While most plugins should work out of the box, some plugins may require specific configurations or adjustments for Neovim. Consult the documentation or GitHub repository of each plugin to ensure proper compatibility and make any necessary changes.
Test and refine: Launch Neovim and test your configuration and plugins. Check for any error messages or unexpected behavior and make the necessary adjustments. Neovim provides extensive documentation and a helpful community that can assist you in troubleshooting and optimizing your setup.

Notable Neovim-specific features and improvements

Once you have successfully migrated to Neovim, you can take advantage of its unique features and improvements. Here are a few noteworthy features that Neovim offers:

Built-in terminal: Neovim includes a built-in terminal emulator, allowing you to run shell commands directly within your editor. This feature eliminates the need to switch between a separate terminal window and your text editor, making it easier to interact with command-line tools and build systems.
Floating windows and pop-ups: Neovim introduces support for floating windows and pop-ups, which are highly useful.

Here are some points of comparison between a typical .vimrc configuration file for Vim and an init.lua configuration file for Neovim:

File format: The .vimrc file uses a plain text format, whereas the init.lua file uses a Lua scripting format. Lua is a lightweight and highly extensible scripting language, allowing for more advanced configuration options and logic in the init.lua file.
Plugin management: In Vim, plugin management is typically done using plugin managers like Vundle, Pathogen, or vim-plug, which are included and configured in the .vimrc file. In Neovim, plugin management is often done using Lua-based plugin managers like Packer or LuaRocks, which are included and configured in the init.lua file.
Configuration syntax: The syntax for configuring options and mappings differs between the two files. In Vim’s .vimrc, the configuration is typically written using Vimscript, a custom scripting language specific to Vim. In Neovim’s init.lua, the configuration is written using Lua syntax, which provides a more expressive and powerful language for configuration.
Modularity and organization: The init.lua file allows for more modular and organized configuration compared to the .vimrc file. Lua’s table-based data structure allows you to group related settings and mappings together, making it easier to navigate and maintain the configuration.
Error handling and debugging: Neovim’s init.lua file benefits from Lua’s robust error handling and debugging capabilities. Lua provides better error messages and stack traces, making it easier to identify and debug issues in the configuration file compared to Vim’s .vimrc.
Plugin-specific configurations: While Vim’s .vimrc can include specific configurations for each plugin, the init.lua file in Neovim provides more flexibility and control over plugin configurations. With Lua’s scripting capabilities, you can define custom functions, define mappings, and configure plugins in a more programmatic and dynamic way.
Native Neovim features: The init.lua file allows you to take advantage of Neovim’s native features and APIs directly in your configuration. This includes features like floating windows, job control, built-in LSP support, and more. You can interact with these features using Lua code, enhancing the functionality and extensibility of your Neovim setup.
Community support and examples: While both Vim and Neovim have active communities and extensive plugin ecosystems, the init.lua configuration format in Neovim is gaining popularity. As a result, you may find more up-to-date and Lua-based configuration examples, tips, and discussions for Neovim compared to Vim’s .vimrc file.

It’s important to note that while Neovim’s init.lua file provides additional features and flexibility, Vim’s .vimrc configuration is still widely supported and used. If you’re comfortable with your current Vim setup and it meets your needs, there may not be a pressing need to switch to Neovim and rewrite your configuration. However, if you’re interested in exploring the advantages and possibilities of Neovim, migrating your configuration to init.lua can be a rewarding experience.

Here is how my current nvim config in ~/.config/nvim/init.lua looks like:


-- Packer related config & installed plugins
local status, packer = pcall(require, "packer")
if (not status) then
  print("Packer is not installed")
  return
end

vim.cmd [[packadd packer.nvim]]

packer.startup(function(use)
  use 'wbthomason/packer.nvim'
  use 'nvim-lualine/lualine.nvim' -- Statusline
  use 'nvim-lua/plenary.nvim' -- Common utilities
  use 'onsails/lspkind-nvim' -- vscode-like pictograms
  use 'hrsh7th/cmp-nvim-lsp' -- nvim-cmp source for neovim's built-in LSP
  use 'hrsh7th/nvim-cmp' -- Completion
  use 'neovim/nvim-lspconfig' -- LSP
  use 'jose-elias-alvarez/null-ls.nvim' -- Use Neovim as a language server to inject LSP diagnostics, code actions, and more via Lua
  use 'williamboman/mason.nvim'
  use 'EdenEast/nightfox.nvim'
  use 'williamboman/mason-lspconfig.nvim'
  use 'habamax/vim-rst'
  use 'glepnir/lspsaga.nvim' -- LSP UIs
  use {
    'nvim-treesitter/nvim-treesitter',
    run = ':TSUpdate'
  }
  use 'nvim-treesitter/nvim-treesitter-context'
  use 'kyazdani42/nvim-web-devicons' -- File icons
  use 'nvim-telescope/telescope-file-browser.nvim'
  use 'windwp/nvim-autopairs'
  use 'tpope/vim-fugitive'
  use 'sainnhe/edge'
  use 'sainnhe/gruvbox-material'
  use 'windwp/nvim-ts-autotag'
  use 'folke/zen-mode.nvim'
  use({
    "iamcco/markdown-preview.nvim",
    run = function() vim.fn["mkdp#util#install"]() end,
  })
  use 'akinsho/nvim-bufferline.lua'
  use 'tpope/vim-commentary'
  use 'github/copilot.vim'
  use {
    'nvim-telescope/telescope.nvim',
    tag = '0.1.1',
    requires = { {'nvim-lua/plenary.nvim'} }
  }
  use {
    'nvim-tree/nvim-tree.lua',
    requires = {
      'nvim-tree/nvim-web-devicons', -- optional
    },
    config = function()
      require("nvim-tree").setup {
        sort_by = "case_sensitive",
        view = {
          width = 30,
        },
        renderer = {
          group_empty = true,
        },
        filters = {
          dotfiles = true,
        },
      }
    end
  }

end)

vim.cmd("autocmd!")

vim.scriptencoding = 'utf-8'
vim.opt.encoding = 'utf-8'
vim.opt.fileencoding = 'utf-8'

vim.wo.number = true
vim.opt.title = true
vim.opt.autoindent = true
vim.opt.smarttab = true
vim.opt.smartindent = true
vim.opt.breakindent = true

vim.opt.cmdheight = 1
vim.opt.laststatus = 2
vim.opt.shell = 'zsh'

vim.opt.inccommand = 'split'
vim.opt.hlsearch = true

vim.opt.wrap = false -- No Wrap lines

vim.opt.swapfile = false
vim.opt.backup = false
vim.opt.writebackup = false
vim.opt.shiftwidth = 2
vim.opt.expandtab = true  -- expand tabs into spaces
vim.opt.tabstop = 2
vim.opt.softtabstop = 2
vim.opt.backspace = { 'start', 'eol', 'indent' }
vim.opt.path:append { '**' } -- Finding files - Search down into subfolders
vim.opt.wildignore:append { '*/node_modules/*' }

-- Undercurl
vim.cmd([[let &t_Cs = "\e[4:3m"]])
vim.cmd([[let &t_Ce = "\e[4:0m"]])

-- Turn off paste mode when leaving insert
vim.api.nvim_create_autocmd("InsertLeave", {
  pattern = '*',
  command = "set nopaste"
})

vim.g.loaded_netrw = 1
vim.g.loaded_netrwPlugin = 1

-- set termguicolors to enable highlight groups


vim.opt.cursorline = true
vim.opt.termguicolors = true
vim.opt.winblend = 0 -- adds pseudo transparency to a floating window
vim.opt.wildoptions = 'pum'
vim.opt.background = 'dark'
vim.cmd('colorscheme peachpuff')
require("nvim-tree").setup()



vim.g.mapleader = ","
local keymap = vim.keymap

-- split settings
keymap.set('n', '<Leader>h', ':<C-u>split<CR>', { noremap = true, silent = true })
keymap.set('n', '<Leader>v', ':<C-u>vsplit<CR>', { noremap = true, silent = true })

-- tab settings
keymap.set('n', '<Leader>t', ':<C-u>tabnew<CR>', { noremap = true, silent = true })
keymap.set('n', '<C-t>', ':tabNext<CR>', { noremap = true, silent = true })

-- Up and Down Mapping
keymap.set('n', '<CR>', 'G', { noremap = true, silent = true })
keymap.set('n', '<BS>', 'gg', { noremap = true, silent = true })

keymap.set('n', '<C-p>', ':Telescope find_files<CR>', { noremap = true, silent = true })
keymap.set('n', '<C-b>', ':Telescope buffers<CR>', { noremap = true, silent = true })
keymap.set('n', '<C-c>', ':Telescope git_commits<CR>', { noremap = true, silent = true })
keymap.set('n', '<C-e>', ':Telescope diagnostics bufnr=0<CR>', { noremap = true, silent = true })
keymap.set('n', '<C-n>', ':NvimTreeToggle<CR>', { noremap = true, silent = true })

vim.opt.clipboard:append { 'unnamedplus' }

local nvim_lsp = require('lspconfig')

-- Use an on_attach function to only map the following keys
-- after the language server attaches to the current buffer
local on_attach = function(client, bufnr)
  local function buf_set_keymap(...) vim.api.nvim_buf_set_keymap(bufnr, ...) end
  local function buf_set_option(...) vim.api.nvim_buf_set_option(bufnr, ...) end

  --Enable completion triggered by <c-x><c-o>
  buf_set_option('omnifunc', 'v:lua.vim.lsp.omnifunc')

  -- Mappings.
  local opts = { noremap=true, silent=true }

  -- See `:help vim.lsp.*` for documentation on any of the below functions
  buf_set_keymap('n', 'gD', '<Cmd>lua vim.lsp.buf.declaration()<CR>', opts)
  buf_set_keymap('n', 'gd', '<Cmd>lua vim.lsp.buf.definition()<CR>', opts)
  buf_set_keymap('n', 'K', '<Cmd>lua vim.lsp.buf.hover()<CR>', opts)
  buf_set_keymap('n', 'gi', '<cmd>lua vim.lsp.buf.implementation()<CR>', opts)
  buf_set_keymap('n', '<C-k>', '<cmd>lua vim.lsp.buf.signature_help()<CR>', opts)
  buf_set_keymap('n', '<space>wa', '<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>', opts)
  buf_set_keymap('n', '<space>wr', '<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>', opts)
  buf_set_keymap('n', '<space>wl', '<cmd>lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))<CR>', opts)
  buf_set_keymap('n', '<space>D', '<cmd>lua vim.lsp.buf.type_definition()<CR>', opts)
  buf_set_keymap('n', '<Leader>n', '<cmd>lua vim.lsp.buf.rename()<CR>', opts)
  buf_set_keymap('n', '<Leader>ca', '<cmd>lua vim.lsp.buf.code_action()<CR>', opts)
  buf_set_keymap('n', 'gr', '<cmd>lua vim.lsp.buf.references()<CR>', opts)
  buf_set_keymap('n', '<space>e', '<cmd>lua  vim.diagnostic.open_float()<CR>', opts)
  buf_set_keymap('n', '[d', '<cmd>lua vim.lsp.diagnostic.goto_prev()<CR>', opts)
  buf_set_keymap('n', ']d', '<cmd>lua vim.lsp.diagnostic.goto_next()<CR>', opts)
  buf_set_keymap('n', '<space>q', '<cmd>lua vim.lsp.diagnostic.set_loclist()<CR>', opts)
  buf_set_keymap("n", "<space>f", "<cmd>lua vim.lsp.buf.formatting()<CR>", opts)

end


-- Use a loop to conveniently call 'setup' on multiple servers and
-- map buffer local keybindings when the language server attaches
local servers = { "pyright", "tsserver" }
for _, lsp in ipairs(servers) do
  nvim_lsp[lsp].setup {
    on_attach = on_attach,
    flags = {
      debounce_text_changes = 150,
    }
  }
end

require'lspconfig'.pyright.setup{}


local status, null_ls = pcall(require, "null-ls")
if (not status) then return end

null_ls.setup({
  sources = {
    null_ls.builtins.diagnostics.eslint_d.with({
      diagnostics_format = '[eslint] #{m}\n(#{c})'
    }),
    null_ls.builtins.diagnostics.fish
  }
})


function StripTrailingWhitespace()
  if not vim.bo.binary and vim.bo.filetype ~= 'diff' then
    vim.cmd('normal! mz')
    vim.cmd('normal! Hmy')
    if vim.bo.filetype == 'mail' then
      -- Preserve space after e-mail signature separator
      vim.cmd('%s/\\(^--\\)\\@<!\\s\\+$//e')
    else
      vim.cmd('%s/\\s\\+$//e')
    end
    vim.cmd('normal! \'yz<Enter>')
    vim.cmd('normal! `z')
  end
end

vim.cmd('autocmd BufWritePre * lua StripTrailingWhitespace()')
-- Show space and tab characters
vim.o.list = true
vim.o.listchars = 'tab:› ,eol:¬,trail:⋅,nbsp:␣'

This config is inspired by the Single File Nvim Config post by Fatih Arslan

Python Performance Optimization: Memory-Efficient Collection Handling

Thu, 24 Feb 2022 00:00:00 GMT

This is a good technique for managing memory when working with large lists or QuerySets. However, there are a few changes that could make this code more effective.

First, the batch_qs and batch_list functions could be made more general by using a typing.List or typing.Iterable type hint for the list_arr parameter instead of a list type hint. This would allow them to be used with any iterable type, not just lists.

Second, the batch_list function could be simplified by using the built-in range function to generate the indices for each batch. Instead of using a for loop with a start and end variable, you could use a range object with a step value equal to the batch size.

Here’s an example of how this could be implemented:

from typing import Any, Iterator, List, Iterable

def batch_list(list_arr: Iterable[Any], batch_size: int) -> Iterator[Any]:
    for start in range(0, len(list_arr), batch_size):
        yield list_arr[start:start+batch_size]

Finally, the batch_qs function could be made more efficient by using the QuerySet’s iterator method to iterate over the queryset in batches. This would avoid loading the entire queryset into memory at once, which can be slow and use a lot of memory for large querysets.

Here’s an example of how this could be implemented:

from django.db.models.query import QuerySet

def batch_qs(qs: QuerySet, batch_size: int) -> Iterator[QuerySet]:
    return qs.iterator(batch_size=batch_size)

Overall, these changes would make the code more general and efficient, allowing it to be used in a wider range of scenarios.

Remote Work Success Guide: 7 Years of Practical Experience and Best Practices

Thu, 26 Mar 2020 00:00:00 GMT

Covid-19 has forced all Software companies to adopt Remote Work for their workforce. Anybody who has experience with remote work will tell you that it’s not easy to be productive working remotely. I have had the opportunity of working remotely (The company that I work for is the Netherlands based) and I have been working remotely from Pune for a period of more than 7 years. I think this experience gives me some sort of authority to speak on this matter.

The Following are some tips I can give to people who are new to this kind of lifestyle and mode of working:

Hardware: The first advice I would give is to invest in good and fast hardware. The companies should give their developers a decently fast machine and also reimburse the Internet connection at the employees’ home. Internet Speed on the upwards of (100 Mbps) should be good. It is also important for calls and meetings over the internet to go smoothly. Imagine someone building their docker containers on a shitty 3g connection. They will lose all hope and motivation from their life. Also, invest in yourself. Buy a good monitor/monitors (I feel 24 inches and higher is good and 27 inches is probably the best bet), a good keyboard and gaming mouse (better ergonomics) and a good chair. Believe me, you will be way more productive when you are not wrestling with back and hand pain because of poor ergonomics.
Software: Use software like (rescuetime, wakatime) to track how much of your time is spent and where it is spent.
Limit the use of Social Media on your phone or just budget that time, so that you can only use like 15 mins of your time daily on Social Media.
Routine: The most important thing to remember while working remotely is to follow a routine. People think that working remotely can get rid of their 9-5 routine and work at their own time. This might be true but not advisable. You need to stick to a routine and work only during those hours so that office work doesn’t intrude on your time with family. Try to start your workday as early as possible to do work without interruptions. This also helps if your teammates are in a different time zone than you. Also, if you need to step out of the house, let your team know so that they won’t be waiting for a reply from you while you’re away.
Communication: This is the most important thing to remember while you are working remotely. Be explicit and as verbose as possible. Over-communication is better than no communication while working remotely. If something works, update it. If something doesn’t work, make sure you communicate as soon as possible so that team members can help you.

I also recently started daily update standups every evening (since all our team is remote because of Covid-19) and I could already see things moving better and clearer.

Documentation & Testing: While working remotely, you need to do better work. To do better and more correct work, you need to write good code that is documented properly and works correctly (tests to enforce that). With remote work, the only thing that shows you did something is your work and not just you coming to the office. This also means at the end of the day, you need to have something to show for what you achieved/solved that day. This is very hard. If you are having a bad/anxiety-filled day, let your managers know. It’s okay to have a bad day when nothing goes your way. Also, to enable async communication, having good docs with the code is very important. If something can be learned by just reading the docs, then it should be that way.

Also, came across this wonderful list of tips by Mitchell Hashimoto. These tips come from real experience and are very nice.

The force to remote for much of the workforce is going to be very positive but also create a ton of FUD. Lots will "get it" and it'll work for them and they'll be forever changed. Many will realize it isn't as simple as pretending your at-home desk is your in-office desk.
— Mitchell Hashimoto (@mitchellh) March 11, 2020

A Somewhat Sane Guide for Software Development

Thu, 06 Feb 2020 00:00:00 GMT

I have been writing code professionally for around 8 years now. In this period, I have acquired some knowledge and formed some opinions on how software should be written and what practices to follow.

The guide is divided into following sections:

Git Guidelines
Backend Development Guidelines
Frontend Development Guidelines
DevOps Guidelines

Git

Mastering version control such as Git is very important. Following are some tips and techniques to get better at using Git.

Commit early, commit often. There is no shame in committing code that is work in progress. Infact, early commits help spot design issues very early in the development.
Make a Draft PR as soon as you have a POC(proof of concept) ready and invite one of your peers to review the code. Early feedback helps spot issues, obvious mistakes and even typos early.
Make atomic commits(meaning the code in the commit is doing one thing). Do not add a diff of 20 files doing all different things. It just make things very noisy and makes hard for reviewer to do their job.
Avoid doing multiple things and do things in a proper flow.
Write good commit messages. A good guide is here https://chris.beams.io/posts/git-commit/
Setup your git properly with correct emails (For eg: your git configuration should be setup to use the work and personal emails depending upon what project you are on.
Don’t get high on your own supply. Unless absolutely urgent do not merge your own PRs. Ask a coworker to review the code.
Always create release and tags while doing a production release. No code gets pushed to production without doing this.
Write good release notes clearly mentioning the fixed bugs and the features built.
Commit message should contains reference to the github issue.
Sign git commits using GPG. It helps ensure the authenticity of the person doing the commit. Refer link here. https://help.github.com/en/articles/signing-commits
Be honest, direct and respectful while reviewing the code. If you think something could be better (give a meaningful & logical explanation supplemented by suitable code and source)
Try to use a commit message template for consistent commit messages. You can use something like this:

Save the below as a file named .gitcommitmessage in your home directory, replace the Authored-by and Signed-off-by with your email

# build, chore, ci, docs, feat, fix, perf,
# refactor, revert, style, test: subject


# Body


# Any references to tickets, articles etc?
- Github Issue:



Reported-by: team member <teammember@example.com>
Signed-off-by: Vinit Kumar <mail@vinitkumar.me>

You this template while commiting like this:

Edit your ~/.gitconfig file

[commit]
  gpgsign = true
  template = ~/.gitcommitmessage

The full template could be invoked using git commit. You can always use the git commit -m "commit message". Just try to prefix the commit with one of these (build, chore, ci, docs, feat, fix, perf, refactor, revert, style, test: subject), so that the context is clear.

If something needs more explanation that usual, it is a good idea to write detailed commit message. This is better approach than writing a lot of comment on the code, because comments might

get outdated or changed, but the commit is immutable for that piece of code and the context is unique.

Every developer needs to fork the repo from the upstream into their own user account.

This workflow is based on an important concept. There are two kinds of repos here:

Upstream Repo (For eg: https://github.com/django/django)
Developer Repo (For eg: https://github.com/vinitkumar/django)

Some ground rules are:

Use good branch name prefix such as (feature/feat, bugfix/bug/fix, refactor/chore/cleanup) and then a clear branch name.
No branch is pushed directly(feature/bugfix/refactor) to the upstream directly.
Upstream contains only three branches at any time. (develop, staging, master)
Anything on upstream develop is releasable to testing/develop server and is testable for the team other than the dev

themselves.

Anything on upstream staging is releasable to staging and is of atleast beta-quality.
Anything on master is releasable to production.
The default branch of all projects is develop (on upstream). This means all Pull Requests are made to develop.
In case any urgent fix(hotfix) needs to be made from staging or master, the branches are made from upstream staging/master and the pull request is made to master or staging and not to to the develop branch. The fixes are then merged downwards from master -> staging -> develop.
We follow semantic versioning here so vX.Y.Z (X is Major, Y is Minor, Z is Patch version) only.
Releases can be created from staging and master. With cleary indicating that if it is a stable release or release candidate.
Always keep your develop in sync with the upstream develop repo.

Following are some commands for day to day work:

Steps to keep the fork’s develop in sync

git fetch upstream # fetch upstream and all branches
git checkout develop # checkout local or own develop
git merge upstream/develop # get the changes from the upstream and merge to your local.
git push origin develop # push the code to the develop branch of your fork

Create a bugfix/feature/refactor branch for regular development

# first sync the develop
git fetch upstream # fetch upstream and all branches
git checkout develop # checkout local or own develop
git merge upstream/develop # get the changes from the upstream and merge to your local.
git push origin develop # push the code to the develop branch of your fork

# then create a branch from develop

git checkout -b feature/get-user-data
...
...
# get work done, commit code
# push the code to your brach
git push origin HEAD
# make pull request to the upstream develop

Get the code synced into an existing branch

# after getting the branch synced up like this:
git fetch upstream # fetch upstream and all branches
git checkout develop # checkout local or own develop
git merge upstream/develop # get the changes from the upstream and merge to your local.
git push origin develop # push the code to the develop branch of your fork

git checkout feature/existing-branch
git merge develop # merge conflicts may come, resolve them and then commit
git push origin feature/existing-branch

Hotfix workflow

Get the upstream first

git fetch upstream # fetch upstream and all branches
# checkout staging/master depending on where the fix needs to be made
git checkout -b hotfix/major-crash-xyz
# implement the fix
# commit the fix
git push origin HEAD
# make a PR to the source branch, so if it is created from staging, it is made to staging or if it is created
# from master it is made to master

Get the hotfix changes to the branches lower down the upstream master or staging

# after the hotfix is merge to master
# do this:

git fetch upstream
git checkout upstream/staging && git checkout -b staging
git merge upstream/master
git push upstream staging


git checkout develop
git merge upstream/develop
git push origin develop
git merge upstream/staging
git push origin develop

# after the hotfix is merged to staging
# do this:

git fetch upstream
git checkout upstream/staging && git checkout -b staging


git checkout develop
git merge upstream/develop
git push origin develop
git merge upstream/staging
git push origin develop

Benefits

Doesn’t pollute the upstream repo with not needed branches
Gives the developer enough freedom to commit code in their own fork for anything experimental/not-ready-for-production.
It is better when more than one dev is committing to a project. It prevents conflicts and gives more clarity.

Back end Development Guidelines

Write design docs before doing anything major, invite feedback from peers and debug the idea even before a line of code is written. (https://dave.cheney.net/2019/02/18/talk-then-code, https://medium.com/dropbox-design/how-do-you-design-a-design-doc-d7b2f1fa4a0c)
Write defensive code. Do not trust user input. Design for failure. The services might go down at the worst time and your system should consider that into account.
Always use ORM when possible, drop to RAW SQL only when there is a performance issue. Get the RAW SQL audited before putting it live.
Write terse, clear code that is modular and dry. Do not try to do a lot of things at once.
Document any gotchas, assumptions, hard coding with as detailed comments as possible. It will help the team save tonnes of time while debugging issues in future.
Use standard http Status code. Use standard libraries for dealing with http, REST (like DRF, Retrofit). Do not try to reinvent the wheel unless you are 100% sure your implementation is better than these.
Use stable and popular libraries.
Focus on performance & security while writing back end code.
Write DRY, reusable and testable code.
The most critical parts of the system must be unit tested. If it is not easy to test a part of code it is indicative of code smell and a refactor must be done.
Write test with code. Use assertions to enforce correct behaviour. Fail early, fail loudly so that we can figure and fix the errors.
Use tools like newrelic (for performance) and sentry(for error tracking) so that we are aware of the issues before our customers report them. Really helps when there is not a big QA team in place.
Version the APIs that you produce very important since we in a SOA architecture, you can’t push an incompatible change that will break other services. If required, they will be done in a separate version (like apiv2/)
Clear responsibility is enforced within the services. For eg: No two services write to the same table concurrently. This causes deadlocks and is bad for performance.
Long running processes are delegated to background jobs and are not run on the main thread.
Timeouts are added to every external services we are interacting with.

Frontend development guidelines

Focus on accessibility while building UIs.
Master SASS and modern CSS. It helps write better structured CSS code.
Focus on learning build tools such as Webpack/Parcel. It is how CSS and JavaScript bundled these days and mastering them will help you modify their configuration as per your taste.
Read JavaScript basics at Mozilla Developer Network.
Reads the docs at reactjs.org and their release notes to learn the latest trends and correct patterns.
Use eslint to lint your code and get rid of most of the silly mistakes and syntax errors.
Write DRY code(DRY = Do not repeat yourself). If you are copy pasting same logic in two places, better make a function out of it.
Write reasonable and simple code that is easy to reason about. Keeping things simple is helpful in debugging.
If the component is very large(more than 200 Lines Of Code) and is doing a lot of things at once, try splitting it into smaller components.
Separate logic from presentation. The presentation components shoulb be dump and just depend on the data for presentation.
Try not to write a lot of if, ternary operators inside the render method. Use a boolean flag for that and keep the logic inside the templating to the minimum.
Prefer using PureComponent instead of Component while using Class based components.
Cleanup eventhandler set in ComponentDidMount in ComponentWillUmount because not doing so can cause memory leaks.
Type check the components with PropTypes.
Write simple components that do one thing and only one thing well. Make it composeable so that it can be reused with ease.
Think about the stability, popularity and trade-offs while using a new library and if you can justify increasing the bundle-size.

DevOps

Use standard, stable and well documented platform.
Use multi-zone DB to embrace for regional failures and quick failover.
Have Database scheduled to a different cloud service securely (for example: Use s3 in case the database is hosted on Google Cloud and Vice Versa)
Test the restore and snapshots. Maintain automatic backups.
Backup Database, Put apps and services on maintenance while doing major upgrades/migrations.
The Configuration should definitely be version controlled and tags are maintained. (follow semantic versioning)
Performance, security and stability of the cluster are the corner stones to live by.
While evaluating any new service, library refer the above and ask yourself if it is going to make it better or is it going to make it better.
Trade-offs if any needs to be documented and made very clear.
Maintain better dev prod parity. Ideally, the apps should checklist all the columns of 12 factor apps. Refer this(https://12factor.net)
Test new tech, plugins in local -> staging -> production. Push code to production only when there are no known bugs or issues.

Influential Programmers: A Personal Tribute to 10 Open Source Leaders

Thu, 23 Jan 2020 00:00:00 GMT

Everyone has their heroes. Even programmers have their heroes. This is a small list of programming heroes I admire. I don’t claim that these are the best, their might be many others but these are the one I know from my limited experience. So takes this list with a grain of salt.

Heroes

Daniel Stenberg (C)

Daniel is the lead developer and creator of the CURL project. If you deal with any web-services either as a developer or end-user, you have used his code. He also livestreams some of his coding sessions on stream and they are informative and fun to watch.

Daniel is excellent at Systems programming, Network, http and ofcourse a master “C” developer.

Brad FitzPatrick (Go)

Brad currently works with ~~the Go team~~ TailScale. In a previous life, he founded LiveJournal, wrote Memcached and many other free software. He is probably my favorite of the lot and I really like his personality.

He is one of the most accomplished programmers of the recent generation, and he just keeps on writing code that matters and gives it away for free.

Brad also seems like an excellent dad and family man (from his twitter feed) and it is especially inspiring to me as a new Dad.

Salvatore Sanfilippo aka antirez (C)

Antirez is the lead and creator of popular Open Source database Redis. He is a great programmer and very humble in person. I learned so much from him. Just read this blog post and you will understand what I am talking about http://antirez.com/news/124

He writes his code in C “that almost reads like poetry” in Vim. He is very strong in networking, data structures, and algorithms. You can learn more by reading his code and blogs than any other book in the field of system programming. He is also a family man and often advocates having a healthy work-life balance and it is almost inspiring to emulate his journey.

Jonathan Blow (Jai, The Witness game)

Game developer of great games like “The Witness”, he is highly opinionated, charismatic and speaks what’s on his mind. He mostly has very good advice about programming and doesn’t hesitate to call a spade a spade. In addition to working on this new game, he has also been writing a new programming language called Jai. It’s a Systems programming language that compiles fast and aims to replace C++ for writing the game engines. He also regularly live-streams his coding sessions, where he sometimes works on the engine and on the compiler.

Listening and reading to him, inspires me to think deeply and work hard on improving my craft.

David Beazely (Python)

David Beazely is one of the best teachers of Python in the world. He is like this mad Computer Scientist that just keeps on producing great software and resources regularly and every time he surpasses his past standards that are already very high.

I also relate and learn more from him as he is a Python Guru and Python has been the source of most of my income to date. His enthusiasm and spirit towards programming and Python are infectious and I just love watching his talks.

Raymond hettinger (Python)

Raymond as been a Python Core Developer for over a decade or more and is a fantastic Python educator. His talks show his deep knowledge of Python and programming in general. Plus, he is a fantastic speaker. He is probably one of my favorite speakers in any programming language community. People like him are a gift for people like me who are self-taught and can’t afford the costly training materials or courses.

Bryan Cantrill (C, Dtrace)

He is probably one of the most gifted systems programmer. Recently, he has been programming a lot in Rust and his talks are always filled with a lot of useful information. I have not done a lot of System Programming in my daily work but it always fancies me, and I am sure going to do more of it in the future.

Guido Van Rossum

Guido is simply amazing. His work changed the lives of many people including me. In a world filled with difficult programming languages, he made a simple and powerful programming language that was welcoming and gave me the confidence of implementing my ideas into code. He is not just very technically strong, but he is also a very nice person and is doing a lot for diversity and inclusiveness. He also gave up his BDFL status last year and Python is being run by an elected group of people (core devs).

Python has been the key point in my life. It has provided me with a respectable job and has enabled me to provide for my family. I will always thank Guido for that.

Remy Sharp

Remy is an awesome British programmer and an all-around great guy. He runs his own company and has been one of most influential JavaScript programmers. He writes useful tools and services (like nodemon, jsbin and gives it all for free). His livestreams are also informative and there is a lot you can learn from watching him code and debug. I give him credit for a lot of my JS knowledge. I have been following and learning from him a lot from the start of my professional programming journey since(2012) and remember him using Chrome dev tools as an editor for development. He is also a family man and is a great chap to look up to.

Coding principles every engineer should know

Mon, 08 Apr 2019 12:48:00 GMT

IMPORTANT: Cross posting from this medium article https://medium.com/@sschillace/coding-principles-every-engineer-should-know-b946b48cc946 since I do not like medium as a platform and I do not want to loose this port in matrix:)

The post has been written by Sam Schillace and all references to me/I is referenced to Mr. Sam

Throughout my engineering career, I’ve had the opportunity work alongside and learn from many incredibly talented people, solve some serious technical challenges, and scale several successful companies. Recently, I was talking with the engineering team at Box about what I’ve learned along this journey, and what came out of that conversation were my personal engineering principals. These aren’t rules or engineering guidelines. They’re simply the principles that I pay attention to when I write and operate code.

Be paranoid.

This one comes naturally to me. Since I’m mostly self-taught as a programmer, I never trust computers. I never trust that the system I just launched is really up. That the bug I fixed is really fixed. That code really does work the way I think it does without a test. I don’t trust anything. I don’t even trust myself! I never trust that I understand anything as well as I think I do until I check more than once. Paranoia is my friend, and it should be your friend, too. Always try to find a way to test assumptions along some other path, or get a second set of eyes to see what you’ve missed. Most of the time it’s not needed. Sometimes it’s really important.

Don’t lie to the computer.

Another way to say this is “avoid leaky abstractions.” Don’t use systems in ways they’re not meant to be used. Don’t count on side effects. Don’t do things that won’t be obvious to the next person because the system wasn’t designed for them or they’re undocumented. If usage is three orders of magnitude more than current usage, then you should probably rethink the design. If the contract implies, but doesn’t guarantee, your use, you should change the component and the contract to be aligned. Computers are nasty things. They always bite when lied to, eventually.

Keep it simple.

We like building things and solving problems. That’s why we do what we do. But a lot of the time, just because we can see a problem that could be solved, doesn’t mean it’s useful to solve it right now. I always think of myself as a fairly dumb programmer — I like clean, simple designs that are easy to understand. And this is a high challenge — anyone can solve a problem in a complex way, but only good programmers can solve problems in simple, understandable ways. It’s much harder to really think through the problem and solve only what needs to be solved in a simple, robust manner. Making yourself understood is the most important thing. Most time in code is spent maintaining, not creating.

First rule of optimizing: don’t.

This is from a good book by John Bentley called Programming Pearls. (It’s explicitly meant to help you learn to think like an experienced programmer. It may be an old book but most of the lessons are incredibly relevant today.) Optimization can take many forms: speed, future-proofing, potential scale, possible uses, etc. The problem is, most optimization is ultimately never used, and, more or less by definition, optimization makes designs more complicated. So, first rule of thumb is don’t optimize until it’s really clear that you understand the problem completely. (His second rule: “don’t optimize, yet.” Meaning, even if you do understand it, don’t optimize until you really need to.)

Don’t just fix the bug; fix all possibility of it ever happening again.

Don’t be sorry if you made a mistake — be angry and make it something you never have to think about again. I hate bugs. I hate systems that let me create bugs. I hate it when my own software lets my fragile human brain down and I create a bug that could have been avoided. And I really, really hate fixing the same bug twice. So I try as much as I can, every single time I fix a bug, to think about the following: where else might this bug be happening now? Where might it happen in the future? What are the adjacent patterns that create similar bugs? And how can I kill all the bastards at once, right now?

Question assumptions constantly.

Because I have spent most of my time in my own startups, I’ve gotten in the habit of asking myself constantly “Why am I doing this? What problem does it solve? Is there a better way? Is there something else I could do instead that’s more important?” You should have that attitude all the time. Constantly be questioning the assumptions given to you. What’s the real problem you’re solving? Did someone ask you to solve an effect rather than the root cause? Is the solution complete? Over-complete? Is the impact worthwhile?

Think long term. Slow down, it goes faster.

This might be one of the most important ones. It’s easy to hack things out. As engineers, we like efficiency; we like to build as many things as we can. But if we don’t build for the long term, eventually it gets harder and harder to build anything. Sometimes we don’t understand the problem at first and we write code that we later have to back out. Sometimes we do things that are easy for our local problem, but make things worse or harder for someone else or for a larger problem. Sometimes we rush and don’t finish the design, and this causes much more time later on for someone to fix. Sometimes we don’t bother to write it the right way, we just make a copy or hack something in because we’re under time pressure or don’t want to really think it through. I’ve seen all these things too many times. Others have said this better than I have. But I’ll repeat — the goal is building the largest number of great features, reaching the largest number users over time. The area under the curve for a given day doesn’t add much, no matter how much gets done on that day, relative to all the days added together. Think long term.

Care about your code.

I guess this one doesn’t need much explanation, but it’s still something I see people missing from time to time. Take pride in your work! Care about the code you produce! I usually think of my poor future self, having to deal with my crappy code, when I’m tempted to be lazy and cut a corner. You don’t have to take this to an extreme — I used to joke at Google that other engineers treated their code like a pet, where my relationship with mine was more like a ranchers — pragmatic, not sentimental. But even still, I always hate it if my code isn’t well designed, doesn’t work well, isn’t readable, all that stuff.

Cheap, fast, right — pick two.

This is the iron triangle of software. This is the way the world of software engineering works. But it’s not an excuse for complacency. In fact, this is your opponent every single day. The difference between good and great programmers is often measured in how well they navigate the iron triangle. And really great ones find ways to bend it and get some of all three, more often than not. Try to be that kind of programmer — can you find a more elegant design that’s faster to build and is still right? Can you relax some constraint in the spec to get to the goal more quickly? You might not always be able to do that; in fact, you won’t beat the triangle. But if nothing else, make sure you understand what compromise you are choosing, and why, and that it’s the right one for the current situation.

Conclusion: Be curious. Learn as much as you can, all the time.

Okay, this one is more career advice than anything else. But if you’re not curious and don’t really care that much about learning new things as an engineer and don’t care about new tech or new languages or new ideas, then why are you here? By no means are my principles perfect or an absolute representation of thinking/acting like a successful engineer, but I’m willing to bet there’s a fair amount of overlap with what others might be thinking. I’d love to hear your thoughts.

How To Manage Infra in 2019

Fri, 05 Apr 2019 07:19:00 GMT

Infrastructure is one of the most hotly discussed topics in Software development these days. There are so many tools, so much to learn that very few people actually know what to do and what the best practices are. Everyone wants to jump on the microservice bandwagon. However, it’s not as easy as it seems. I’ve meditated quite a bit on this and have come up with these points that I think are good tips to follow: - Use standard, stable and well documented platform. - Use multi-zone DB to embrace for regional failures and quick failovers. - Have DB backups scheduled to a different cloud service securely (for e.g., s3 in case the db is hosted on GCE/GKE)

Test the restore and snapshots. Maintain automatic backups.
Backup Database, put apps and services on maintenance while doing major upgrades/migrations. - The Config should definitely be version controlled and tags are maintained. (follow semantic versioning) - Performance, security and stability of the cluster are the corner stones to live by. - While evaluating any new service or library, refer to the above and ask yourself if it is going to make it better.
Tradeoffs, if any, need to be documented and made very clear.
Maintain better dev/prod parity. Ideally, the apps should satisfy all the principles of 12 factor apps. Refer to https://12factor.net
Test new tech and plugins in local → staging → production. Push code to production only when there are no known bugs or issues.

The Minimalist Developer: Maximizing Productivity with Fewer Tools

Wed, 06 Mar 2019 11:00:00 GMT

We are a big fan of tools. We use them daily in almost everything, but at one point in time, they pollute our mental space so much that we just forget to think and do as the tools dictate. A common example could be smart-phone. It was meant to keep us mobile and connected but now, it has become so dominant and addictive that it is more of a bane than boon. Similarly, in programming, we use so many tools and IDEs, but we rarely master a subset of these. It is a sad situation in my opinion. I was one of those guys who will try every tool or software that comes out. But now, my thinking has totally changed. Right now, only three things matter to me while selecting a tool: - Stability: is the tool stable enough and has a good stable ecosystem? - Performance: is the tool performant enough, or is it going to eat away my RAM and CPU cycles? - Speed: is fast enough so as to match my thoughts and do not block me while I am working? Keeping these in mind, only one tool that I use passes all these tests and that is [Vim](https://www. Vim. org)![screenshot](https://cldup. com/A35GFuVx77.png) My Vim is configured to be fast, functional and as a mere extension to my thoughts. My muscle memory in Vim is strong enough now so that I do not have to remember keybindings to edit text, replace or write good code. The core of the plugins I use is YouCompleteMe, Ale, and Fugitive. Also, I have gone cold turkey with Vim so there is no fallback editor in case I struggle to do something in Vim. It has helped me learn a lot of good shortcuts and tricks for editing code in Vim. Also, watching the live stream of experience Vim veterans like Armin and Gary has helped a lot. This post is not about IDE bashing or anything like that. It is mostly about what works for me and why? If you use ann IDE, spend some time mastering it and learning as much as you can about it. In my opinion, the goal should be to get better at the tool you use and get very good at that. So good that the tool becomes an extension of your mind and you do not have to have an overhead while using that tool. Life and time are both limited commodities, and we should optimize our tooling to make sure we enjoy them to the fullest and without wasting time on bloated tools.

6 years of full time job

Fri, 01 Feb 2019 06:31:00 GMT

Today, I am completing 6 years of my full time employment with [Socialschools](https://socialschools. nl). It has been an incredibly long time and there has been highs and lows but mostly it has been a great experience writing code and having fun while doing it. I am very proud of the product I have helped build and make it succeed. There are various factor that led me stay with this company for this long: - People: I was lucky enough to be working with the best people who are friendly, empathetic and have impeccable professionalism. - Work Life Balance: People realize that everyone has a life outside the work and respect that. - Quality of Work: I have been very lucky in being able to work on very hard problems and solve them. This doesn’t happen too often with many companies. - Trust: You are more motivated to do things in the best possible way when your teammates trust you. - Ownership: You are given ownership of a part of product and people trust you that you will make the best possible decision for it and the team. Nobody can look very far in the future and say what they are going to do but at this point of time, I feel incredibly lucky and full of gratitude to everyone who has played a part in my journey. Some past posts about the same: - [Four years of full time job](https://vinitkumar. me/articles/2017/03/01/Four-years-of-full-time-job. HTML) - [One year at job](https://vinitkumar. me/articles/2014/02/08/One-year-on-job. HTML)

How To Convert LaTex to PDF on macOS

Wed, 16 Jan 2019 00:00:00 GMT

I have been writing my resume in LaTeX for more than a decade now. Writing your resume in LaTex has it’s own benefits. You can check it out here:

benefits of doing the resume in latex

Now, writing your resume in all LaTex is all well and good but converting it into pdf on macOS is a task on it’s own. The MacTeX package is a BIG download of around 6GB and it’s not worth spending so much time and energy for only trying to convert your resume from LaTex to PDF. Well, you can ofcourse use one of the online latex-to-pdf converter or you can install the basictex package and set your local mac environment capable of converting to PDF.

Follow these steps to get it working:

# install basictex using brew #NOTE your password might be required
brew cask install basictex
# try to install texlivefly, it complains about tlmgr outdated
sudo tlmgr install texliveonfly
# update tlmgr
sudo tlmgr update --self
# now install textliveonfly
sudo tlmgr install texliveonfly

# use the commands using sudo.
# for eg: if your resume file name is vinit_kumar.tex

sudo texliveonfly vinit_kumar.tex

# this outputs a file named vinit_kumar.pdf in the same directory
# now, open this file like this to check if all your changes made it through.

open vinit_kumar.pdf

Credits where it’s due: Get Mactex Faster

The idea came from this website, though the issue was it was not working without sudo. Hence, wrote this post more of an reminder of how to get LaTex to PDF working on macOS

Lightweight LaTeX to PDF Conversion on macOS: A Minimal Setup Guide

Wed, 16 Jan 2019 00:00:00 GMT

I have been writing my resume in LaTeX for more than a decade now. Writing your resume in LaTeX has its own benefits. You can check it out here:

benefits of doing the resume in latex

Now, writing your resume in all LaTeX is all well and good but converting it into PDF on macOS is a task on its own. The MacTeX package is a BIG download of around 6GB and it’s not worth spending so much time and energy for only trying to convert your resume from LaTeX to PDF. Well, you can of course use one of the online latex-to-PDF converter or you can install the basictex package and set your local Mac environment capable of converting to PDF.

Follow these steps to get it working:

# install basictex using brew #NOTE your password might be required
brew cask install basictex
# try to install texlivefly, it complains about tlmgr outdated
sudo tlmgr install texliveonfly
# update tlmgr
sudo tlmgr update --self
# now install textliveonfly
sudo tlmgr install texliveonfly

# use the commands using sudo.
# for eg: if your resume file name is vinit_kumar.tex

sudo texliveonfly vinit_kumar.tex

# this outputs a file named vinit_kumar.pdf in the same directory
# now, open this file like this to check if all your changes made it through.

open vinit_kumar.pdf

Credits where it’s due: Get Mactex Faster

The idea came from this website, though the issue was it was not working without sudo. Hence, wrote this post more of a reminder of how to get LaTeX to PDF working on macOS

How to Use React with djangoCMS 3.5.2 and above?

Thu, 24 May 2018 00:00:00 GMT

React is one of the most useful frontend library out there. At Socialschools, we use React to render some content using our API from App server. It has been in production since June last year and it is really amazing building neat stuff using both React and djangoCMS.

djangoCMS provides us the best Hybrid experience possible, we render say 70% of the content from server rendered pages and it provides us good support for even running React et. al without any hiccups. The latest version of djangoCMS 3.5.x series came up with a neat feature that allows the content to be refreshed as you edit without need of a reload.

This is from the djangoCMS documentation:

Generally speaking, django CMS is wholly frontend-agnostic. It doesn’t care what your site’s frontend is built on or uses.

The exception to this is when editing your site, as the django CMS toolbar and editing controls use their own frontend code, and this can sometimes affect or be affected by your site’s code.

The content reloading introduced in django CMS 3.5 for plugin operations (when moving/adding/deleting etc) pull markup changes from the server. This may require a JS widget to be reinitialised, or additional CSS to be loaded, depending on your own frontend set-up.

So even though the functionality is very nice and is very good UX for our end users it introduces a serious issue with the frontend frameworks like React. Let me explain:

Let’s say you have a simple React application that looks something like this:

import React, {Component} from 'react';
import ReactDOM from 'react-dom';


class App extends Component {
  constructor(props) {
    super(props);
    this.state = {
      data: null
    }
  }


  componentDidMount() {
    // do a fetch to the API resources and set the data in the state
    this.setState({data: data })

  }

  render() {
    return(
      <div className="container">
      { this.state.data &&  this.state.data.map((element, key) => (
          <span key={key}>{element}</span>
      ))}
      </div>
    )

  }
}

ReactDOM.render(<App/>, document.getElementByID("root"))

This used to work perfectly with the old djangoCMS since everytime you edit a content, there would be a reload and because of that the componentDidMount() will be called and hence there would be an API call and the React app would be rendered.

However, due to the change in the way frontend editing works now, this is no longer the case by default and it cause strange behaviour to occur.

For eg: You filled up the djangoCMS plugin that implemented this React Plugin and it is rendered properly. Now, you wanted to do change in other plugin like Text Plugin. So as a result, as soon as you submit save button for the text plugin after doing the change, the CMS javascript sends a request for the server rendered HTML and replace it in place for the page. The problem here is that there was no page reload, so the react app was never triggered and mounted, so you properly working filled up React app just vanishes from the site.

In case if it’s not clear, the reason for this is: React needs to mount the component to do the API request. Since, the HTML was hot swapped, it never for the opportunity to do so and hence the React plugin gets empty after the edit.

Now, the good folks at djangoCMS are kind enough to make a note of it in their documentation but somehow I missed it before while reading the release notes for djangoCMS 3.5.x

This is their suggested solution:

// catch the cms-content-refresh event and use it
// to trigger actions that are not done due to to Hot SWAP of the HTML
CMS.$(window).on('cms-content-refresh', function () {
  // Render React Again?
});

Now, though this solution gives us the first clue of how to go about fixing it, the code is not just drop-in replacement and won’t work right away in the React and similar apps. You will need to do following to get it working on your React app and similar frameworks.

Here is a more complete solution to get it done.

document.addEventListener("DOMContentLoaded", function() {
  // Handler when the DOM is fully loaded
  window.CMS.$(window).on('cms-content-refresh', function () {
    // render react or call for actions that were skipped because of the
    // change in how djangoCMS behaves now.
  });
});

So if you look at the above piece of code, notice that I used plain JS to look for document.ready event of jQuery, since in most the React apps we do not use jQuery and also, it doesn’t make sense to add more files to your App bundle size when you can get away with it.

The logic to look for “DomContentLoaded” event is that the global variable CMS won’t be available unless all content is loaded and we require it to watch for the cms-content-refresh event. So as a solution we hook up the ReactDOM render method whenever we get catch a refresh event from the CMS.

Following is the updated React App code after accomodating changes for this event handling.

import React, {Component} from 'react';
import ReactDOM from 'react-dom';


class App extends Component {
  constructor(props) {
    super(props);
    this.state = {
      data: null
    }
  }


  componentDidMount() {
    // do a fetch to the API resources and set the data in the state
    this.setState({data: data })

  }

  render() {
    return(
      <div className="container">
      { this.state.data &&  this.state.data.map((element, key) => (
          <span key={key}>{element}</span>
      ))}
      </div>
    )

  }
}

ReactDOM.render(<App/>, document.getElementByID("root"))


document.addEventListener("DOMContentLoaded", function() {
  // Handler when the DOM is fully loaded
  if (window.CMS !== undefined) {
    window.CMS.$(window).on('cms-content-refresh', function () {
      // render react or call for actions that were skipped because of the
      // change in how djangoCMS behaves now.
      ReactDOM.render(<App/>, document.getElementByID("root"))
    });
  }
});

Now, you can just compile your React app and change the files in your template for djangoCMS app and it would not have disappearing content during frontend editing.

Integrating React with Django CMS: Solving Content Refresh Challenges

Thu, 24 May 2018 00:00:00 GMT

React is one of the most useful frontend libraries out there. At Socialschools, we use React to render some content using our API from App server. It has been in production since June last year and it is really amazing building neat stuff using both React and djangoCMS. djangoCMS provides us the best hybrid experience possible, we render say 70% of the content from server rendered pages and it provides us good support for even running React et al. without any hiccups.

The latest version of djangoCMS 3.5.x series came up with a neat feature that allows the content to be refreshed as you edit without need of a reload. This is from the djangoCMS documentation:

Generally speaking, Django CMS is wholly frontend-agnostic. It doesn’t care what your site’s frontend is built on or uses.

The exception to this is when editing your site, as the Django CMS toolbar and editing controls use their own frontend code, and this can sometimes affect or be affected by your site’s code.

The content reloading introduced in Django CMS 3.5 for plugin operations (when moving/adding/deleting etc) pull markup changes from the server. This may require a JS widget to be reinitialised, or additional CSS to be loaded, depending on your own frontend set-up.

So even though the functionality is very nice and is very good UX for our end users it introduces a serious issue with the frontend frameworks like React. Let me explain:

Let’s say you have a simple React application that looks something like this:

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class App extends Component {
    constructor(props) {
        super(props);
        this.state = {
            data: null
        }
    }

    componentDidMount() {
        // do a fetch to the API resources and set the data in the state
        this.setState({ data: data })
    }

    render() {
        return (
            <div className="container">
                {this.state.data && this.state.data.map((element, key) => (
                    <span key={key}>{element}</span>
                ))}
            </div>
        )
    }
}

ReactDOM.render(<App/>, document.getElementById("root"))

However, due to the change in the way frontend editing works now, this is no longer the case by default and it causes strange behaviour to occur. For example: You filled up the djangoCMS plugin that implemented this React Plugin and it is rendered properly. Now, you wanted to do change in other plugin like Text Plugin. So as a result, as soon as you submit save button for the text plugin after doing the change, the CMS JavaScript sends a request for the server rendered HTML and replaces it in place for the page.

The problem here is that there was no page reload, so the react app was never triggered and mounted, so your properly working filled up React app just vanishes from the site. In case if it’s not clear, the reason for this is: React needs to mount the component to do the API request. Since the HTML was hot swapped, it never got the opportunity to do so and hence the React plugin gets empty after the edit.

Now, the good folks at djangoCMS are kind enough to make a note of it in their documentation but somehow I missed it before while reading the release notes for djangoCMS 3.5.x. This is their suggested solution:

// catch the cms-content-refresh event and use it
// to trigger actions that are not done due to to Hot SWAP of the HTML
CMS.$(window).on('cms-content-refresh', function () {
    // Render React Again?
});

document.addEventListener("DOMContentLoaded", function() {
    // Handler when the DOM is fully loaded
    window.CMS.$(window).on('cms-content-refresh', function () {
        // render react or call for actions that were skipped because of the
        // change in how djangoCMS behaves now.
    });
});

So if you look at the above piece of code, notice that I used plain JS to look for document.ready event of jQuery, since in most React apps we do not use jQuery and also, it doesn’t make sense to add more files to your App bundle size when you can get away with it. The logic to look for “DOMContentLoaded” event is that the global variable CMS won’t be available unless all content is loaded and we require it to watch for the cms-content-refresh event.

So as a solution we hook up the ReactDOM render method whenever we catch a refresh event from the CMS. Following is the updated React App code after accommodating changes for this event handling:

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class App extends Component {
    constructor(props) {
        super(props);
        this.state = {
            data: null
        }
    }

    componentDidMount() {
        // do a fetch to the API resources and set the data in the state
        this.setState({ data: data })
    }

    render() {
        return (
            <div className="container">
                {this.state.data && this.state.data.map((element, key) => (
                    <span key={key}>{element}</span>
                ))}
            </div>
        )
    }
}

ReactDOM.render(<App/>, document.getElementById("root"))

document.addEventListener("DOMContentLoaded", function() {
    // Handler when the DOM is fully loaded
    if (window.CMS !== undefined) {
        window.CMS.$(window).on('cms-content-refresh', function () {
            // render react or call for actions that were skipped because of the
            // change in how djangoCMS behaves now.
            ReactDOM.render(<App/>, document.getElementById("root"))
        });
    }
});

Now, you can just compile your React app and change the files in your template for djangoCMS app and it would not have disappearing content during frontend editing.

Important Values

Sat, 19 May 2018 00:00:00 GMT

As humans, I think it is pretty important that we sometimes look deep into the soul and see what defines us and what is the value-system we believe in. Here are values I believe in. Remember this is not an all exhaustive list and I might update it later. - Spread love, not hate. - Empathy is a very important quality. - Do not engage in useless arguments, name calling, trolling. - Life is too short to stay angry on anyone or anything for too long. - Be punctual and respect other’s time as well. - Do not reply in haste, especially when you are angry. - Be easy on yourself. - Life is one of the greatest gifts, value it, cherish it. - Smile often, care about those around you. - Never leave an opportunity for a random act of kindness. - Surround yourself with what you love and block all negativity that bothers you.

Four years of Full time job

Wed, 01 Mar 2017 00:00:00 GMT

So on 1st February 2017, I completed my fourth year working for Socialschools.

Today I complete my 4th year at my full time job. Thankful to everyone I worked with. cc: @stolker @changer @SocialSchools
— Vinit Kumar (@vinitkme) February 1, 2017

I joined Socialschools(then Changer) at the same date in 2013. It's has been quite an honor working with many awesome people.

Then, I was only a fresh graduate dreaming of making a dent in the universe. Today, I am writing code for one of the fastest growing Communication platform for Education in The Netherlands. First, I would like to thank Ruben, Jonathan, and Jos for giving me the chance to work at Changer. Next, the four years at Socialschools would have never been possible without my colleagues. I worked with Robert for most of the time during this journey. He has always been the most friendly person and shares the same passion and fire to do amazing work for Socialschools. Aashish has been a great mentor, friend, and guide and we have spent countless hours building new features, fixing nasty bugs and coffee. Bert has been a great part of Socialschools and has been a driving force is growing us to the next level. Marieke has been pretty amazing at implementation and putting users interest and perspective in the product. I And of course, Jos has been an amazing mentor and technical guide in my growth as an Engineer. The newer team members like Edwin, Harry, Shanice & Trui have been great too and are doing a great job in their field. I would also like to thanks to my Ma, Moma, Papa, Baba, Jhunu and especially my wife Rituparna who have supported me at each and every step and shared the joys and difficulties together. I wouldn’t be here if it wasn’t for them. I would also like to summarize the core of what I have learned during this four years: - Any work you do, You do it with pride. This is something I learn from Ruben early on in my career. We sometimes run after big achievements and stop enjoying small jobs that are always there. Never shy away from work, however small and do it with utmost pride. Even a small CSS change that brings joy to your customer is worth it and you should be happy to do it. Thanks, Ruben:) - Think of users perspective and build for your users and use what you build. - Writing clean, maintainable, testable code requires thinking and it is a very good investment. - You need to have passion and vision when building a product. It will have its lows too and you need someone to motivate, innovate and think out of the box for the product. - You need to be pragmatic while writing code and it’s not only the quantity of code that matters but what you deliver as a product is what really matters. - Enjoy what you do and do what you enjoy!

Some New Learnings

Wed, 22 Jun 2016 00:00:00 GMT

Software Engineering comes with a lot of good learning opportunities. First you learn how to write something by reading tutorials, watching videos etc. Then down the time you learn some new ways to do the same thing and you are blown by it. But only after some days you actually encounter the real hard problems in Computer Science.

Some of them are:

Race conditions
Caching

I have had some very nasty experiences with race conditions. But it opened my eyes to a new set of bugs that could be introduced. Your code might work fine 99% of the time but that remaining 1% could only happen under very rare circumstances. I think being aware and looking out for ways where race conditions might occur could be a good way to minimize if not totally prevent race conditions.

About Caching, it is very important that you understand what you are caching, why you are caching and how exactly your caching is going to work. Just setting up memcached and using a plugin will not help when you encounter a nasty bug caused by caching and you only realize after wasting hours debugging the issue.

Lately, I have been hacking a lot on new things and writing some Go and Node.js. I mostly do that in my late evenings after dinner and it is good fun. I am thinking of documenting my learning process as I learn these new things in a better way. I think it works best for me.

I will probably do a 15 or 30 day challenge, pick up a language and learn as much as I could about that language. The goal here is to learn it deeply and clearly.

Open Source

Sun, 03 Apr 2016 00:00:00 GMT

I joined GitHub in 2010 and it has been my primary source for reading and writing code. I took my baby steps doing open source programming reading others code and it has been a good source of knowledge for me. Since then I have written quite some open source software. I have written some JavaScript, Python and go code and shared those projects in GitHub. Open Source has quite some good benefits as it gives you a nice place to hack on things that fancy your imagination. But there is certain downside to this as well. Sometimes your primary work(paid job) takes up all the time and you don’t have any time and energy left to spend on side projects. This is something that has happened to me since last 1.5-2 years. I have tackled very nice hard and challenging problems at work. I worked on complex scaling issues, performance tuning and lots of new features that really added value to the product. But I hardly found any time for myself. I have struggled for properly managing my time and it makes me a bit sad. But these days, I am writing some amount of code regularly. I hope to write some more open source code in the coming time.

Why I Write Code

Thu, 06 Aug 2015 00:00:00 GMT

I think I was hardly 10 years old when I wrote my first line of code. It was probably some IBM PC and the language was LOGO. It was so much fun. Next, It was GW Basic, then Java and then C/C++/Python. I have been writing code professionally for 5 years now and I still enjoy writing code. I enjoy solving tough problems with code. It gives such a great high when I solve something that seems very difficult at the moment. Last year has been very hectic and I haven’t given much time on writing code on things I enjoy personally the most(side projects). Well, I am still figuring out my dreams at the moment but very soon I will have a clear idea of how and what I want to become in future. But there is one thing that is sure, I would change the world for better than how I found it.

GPS Tracking on Android

Thu, 16 Apr 2015 00:00:00 GMT

Like everybody else, I have an Android phone too. If you are a developer you must have noticed a file called as GPS. LOG. It is the one file which has all your GPS logs in it. This weekend I spend couple of hours hacking with it. He is the outcome. ## How you get tracked First of all, connect your Android device to your computer and copy the gps. log file into your desktop: ```sh cp /Volumes/NO\ NAME/GPS. LOG ~/projects/gps. log

```sh
cat ~/projects/gps. log | grep 'position' > ~/cleangps. log
``` The cleangps. log file contains only data that has coordinates on it. Now, create a log file that only contains coordinates: ```sh
cat ~/cleangps. log | awk '{print $3, $4}' > ~/gpscord. log
# notice the new file is nothing but values seperated by commas, hence write them as csv
cat ~/gpscord. log > ~/gps. csv

This csv file is the basis we use to find that location the GPS log was taken. Prepare virtualenv and install googlemaps: sh mkvirtualenv maps pip install -U googlemaps Also, follow the clear instructions at https://GitHub. com/googlemaps/google-maps-services-Python#API-keys to find your API key. Here is the Python file track. py that would find what these coordinate means and how they related to your daily life and place you are frequent to. Python #! /usr/bin/Python import googlemaps import csv gmaps_client = googlemaps. Client(key='<Your Server Key Here>') with open('~/gps. csv') as csvfile: gps = csv. reader(csvfile, delimiter=',') for row in gps: lat = float(row[0]) longit = float(row[1]) reverse_geocode_result = gmaps_client. reverse_geocode((lat, longit)) formatted_address = reverse_geocode_result[0]['formatted_address'] print row[0], row[1], formatted_address print "=" * 150 Run this file in your terminal by and check out the output, you will get freaked out for some moment. ``` Python track. py

Advanced Mac Storage Cleanup: Command Line Guide for Power Users

Thu, 16 Apr 2015 00:00:00 GMT

Sometimes, your Mac is filled up with files and you can’t seem to understand what really is taking much space. Here is how you can find out. - First of all find disk usage and save it to a log file. Also, find all big files that are there. Grepping using ‘G’ would find all files that are in GB. Also, save the second list to another file so that we are only doing it once. sh du -h > ~/space. log cat ~/space. log | awk '{print $1}' | grep 'G' > ~/highspace. log Next, open a split window and do sh cat ~/highspace. log And Now, start finding the ones which are big one by one. Let’s say one of the entry was 5.6G, Let’s find which one was it. ```sh cat ~/space. log | fgrep -f highspace. log #It will give something like this: 1.2G./.Android/avd/Nexus_6_API_21.avd 2.7G./.Android/avd 2.7G./.Android

following: ```sh
sudo rm -rf Documents/Movie. avi
``` Voila! Repeat this process and remove all files and directories that you no
longer need. # Disclaimer: Do it very patiently and backup everything that's important. This guide is for
very advanced users and you should only do it if you know what you are doing.
I am not responsible for any data loss. Do it at your own risk.

How it went?

Wed, 11 Mar 2015 00:00:00 GMT

Hello People! It has indeed been very long since I last wrote a blog post. It sure feels good to start it again. Firstly, if you enjoy my writing, I am sorry for this big gap. I was very busy in writing code at my work. Here are some important updates about what happened: - I got married! Yay:) I got married in December with my lovely girlfriend. It has been pretty amazing last three months with her. - I wrote various features for my product and there are more than 20k users using those features right now and the feedback has been quite good actually. - I write less code these days and spend more time thinking. I think it is better this way. I felt burnout with my previous lifestyle. Now, I wait to write code every morning. - I feel less annoyed with stupidity around me and have a better coping mechanism. I have decided to be more consistent with my reading habits. I hope to be more sincere this time. That’s it for now. Will write another post soon.

Developer's Guide to Time Management: An 8-Hour Workday Breakdown

Sat, 16 Aug 2014 00:00:00 GMT

Time management is a key quality of any successful person. I have been working pretty hard these days to improve me efficiency. Today, I have decided to follow this pattern while at work. Here is the breakdown. Let’s assume the net hour spent at work is 8. - 50% Time (4 hrs) - Writing Code. - 5% Time (24 min) - documentation of the Code I wrote. - 5% time (24 min) - Writing test on the Code I wrote. - 10% time (48 min) - QA and testing the work I produced. - 20% time (96 min) - Planning and Studying about the topic I need to work on. - 5% Time (24 mins) - Working with colleagues and helping out in case they need any assistance. I felt the need to this timetable because it is really necessary to control the time when you are on tight deadlines. I like giving my all to the work and definitely have very limited time to execute that. So only if my planning and time management is solid I would be able to produce quality work on time. I will produce a analysis of how this goes and how much success I achieve using this methodology. Also, today I have completed my 41 day streak at GitHub.

7 Essential Practices for Writing Better Code: A Developer's Journey

Sun, 20 Jul 2014 00:00:00 GMT

Whether you are working for a big software company or a small sized startup, writing good code is pretty much critical to your success. But the catch is it is not very easy to achieve without proper motivation from your side. I have been coding professionally for almost 4 years now. First two years were as a freelancer and I mostly followed Get Things Done mode during that time. It was okay then because it was mostly a one-time gig and once done, you didn’t have to do anything with it. Though I never wrote really bad code even at that time, the amount of maturity and knowledge required to write code that is maintainable, DRY, and well-documented was clearly not there. While I joined my first company back in 2013, I really struggled against my bad habits. I was able to solve tough technical problems as problem solving is always close to my heart but there were serious issues with my code quality. Sometimes there was some indentation issue and something there were some code repetition. I was lucky to have my Mentor “Ruben” to closely look at my code and review it sharply and give his most honest feedback. Upon pondering about the review I realized most of the issues were coming because a certain amount of thinking and carefulness that was missing from my workflow. I didn’t had my editor configured properly. Mix of tabs and spaces will obviously come back to bite you and code will look ugly on browser even though it looked fine on your editor. (Sublime Text, I am looking at you). Now, after almost an year later I am a improved and mature programmer than what I was at this point of time last year. So what changed? Here is a short summary of things I did in order to get better at writing code: - I started reading classic books on programming. Understanding programming and computer science is pretty much vital to your growth as a software developer. Dreaming about making big in this field without having solid basics is a fools errand. - Read a lot of good code. Discuss about it, blog about it and finally incorporate those into your own code. This is pretty much most important to improve the code you are writing. I started reading a lot of good code, on an average of 1 hour daily. With loads of Open Source projects available on GitHub and bitbucket it is pretty easy to do so. - Follow strict mode in almost every language your code on. Use Pep-8, JSHINT, CSSLint, Grunt. This might be painful at beginning but it would cover a lot of ground that you might not know as you are not an experienced developer. - Learn and use Travis CI and Jenkins system that would automate a lot of these things in your code. - Write a lot of code and open source it. Also, contribute to a good number of OSS projects. I have done a lot of this in the past year and believe me it has really helped in improving. - Read the f**king documentation - This is kind of most important if you want to really use the power the language or the framework provides. Otherwise, you will keep writing shitty code because you were never aware better way exists. - Use version control- Version control gives you an opportunity to look at your code before committing. Use this powerful feature. Always review your code before your commit. Always review a pull request and merge.

Implementing Read-Only Access in Django Admin: A Complete Guide

Sun, 18 May 2014 00:00:00 GMT

Last week, I came across an interesting problem at work. The problem was: > To get read only users in a Django based application. But doing so was not very simple because there is no read only mode for users in Django. In order to solve this, I first started reading answers on stack overflow. Some of those links did pointed me to a correct route. Here, I will document the whole process so that it could help others and serve as a reminder for me as well. First of all, the whole system of authentication in any system originates from permissions. The basis permissions are. Read, Write, Execute. in Unix (chmod is used to set permissions). Django has a cool way of adding the permissions in the meta class. Let’s say we have a model class named Cars. ```Python class Cars(model. Model): name = models. Charfield() year = models. DateField() class Meta: permissions = ( (‘readonly’, ‘Can Read Only Cars’) )

these permissions in the database. You need to run syncdb management command. ```sh
Python manage. py syncdb --all
``` So this just sets the background in place. The real job is getting this
permissions to work. Now, I began to wonder what all things were required to develop this complete
functionality? The first thing that came to my mind naturally was to override templates and
hack ground admin. py. So, I created a new class in Admin. py that was inherited from the admin class
I was earlier using: ```Python
from model import Cars class CarAdmin(admin. ModelAdmin): date_hierarchy = 'date' list_filter = ('status', 'event_instance',) actions = ['accept', 'reject', 'pending'] class ReadonlyCarAdmin(CarAdmin): def __init__(self, model, admin_site): super(ReadonlyCarAdmin, self).__init__(model, admin_site) self. model = model def has_delete_permission(self, request, obj=None): if request. user. has_perm('car. readonly') and not request. user. is_superuser: return False else: return True def has_add_permission(self, request, obj=None): if request. user. has_perm('car. readonly') and not request. user. is_superuser: return False else: return True def has_change_permission(self, request, obj=None): if request. user. is_superuser: self. readonly_fields = () # make sure to remove caching. return True elif request. user. has_perm('car. readonly'): # make the fields readonly for only users with readonly permissions. self. readonly_fields = [field. name for field in filter(lambda f: not f. auto_created, self. model._meta. fields)] return True else: return False def get_actions(self, request): actions = super(ReadOnlyCarAdmin, self).get_actions(request) if request. user. has_perm('car. readonly') and not request. user. is_superuser: # This ensures that that user doesn't not have any actions if 'delete_selected' in actions: del actions['delete_selected'] del actions['accept'] del actions['reject'] del actions['pending'] return actions else: return actions admin_site. register(Car, ReadonlyCarAdmin)
``` Okay, so now we have a robust system in place to ensure whichever user has
readonly permission on Cars Model would only be able to see the model data in
Readonly mode. But this is not it. Here is the part where templates are overridden. First of all save and cancel button on buttom needs to go as we don't need
them. For that, create a new template in templates folder. The templates name is ` change_form. HTML`.
Hence the full pathname is ` carapp/templates/admin/change_form. HTML`. Copy the content from the default Django template (/admin/change_form. HTML) in Django project
add replace this content with this gist: <script src="https://gist. GitHub. com/vinitkumar/48a9cd0c2e35e033659c. JS"></script> This will ensure that the selected user with this readonly only permissions won't be able
get the submit button on his admin page. Now, you have a fully functioning Django Admin with readonly mode. The main effort was to make it
very easy to use and ensure that this feature could run across future versions. Hope this post help anyone else who has to implement something similar.

Complete Guide to Emacs: Setting Up a Modern Development Environment

Sun, 04 May 2014 00:00:00 GMT

I always wanted to use Emacs. Yesterday, I wanted to have a good JavaScript/Node REPL in my editor. Though I had always used Vim for the last 5 years, setting up a REPL in Vim is not very easy. So I decided to give Emacs a try, and so far I am enjoying using Emacs.

Here is a guide that would help you set up Emacs.

First of all, if you are on Mac, install Emacs for OSX from here. You could easily install the GUI version of Emacs for other platforms too.

My Emacs Config

This is my Emacs config which can be used for development in the following technologies:

Ruby / Ruby on Rails
CSS / LESS / SASS / SCSS
HAML / Markdown / Textile / ERB
Clojure (via nrepl)
JavaScript / CoffeeScript
Python
PHP
Haskell
Erlang
Common Lisp (with Slime)

In particular, there’s a nice config for tab autocompletion, and flycheck is used to immediately highlight syntax errors in Ruby, HAML, Python, JavaScript, PHP, and a number of other languages.

Demo

This is my Emacs live in action:

Requirements

Emacs 23 or greater (note that Emacs 24 is required for some functionality, and will likely become the minimum required version some time soon.)

Installation

To install, clone this repo to ~/.emacs.d, i.e., ensure that the init.el contained in this repo ends up at ~/.emacs.d/init.el:

git clone https://github.com/vinitkumar/.emacs.d.git ~/.emacs.d

Upon starting up Emacs for the first time, further third-party packages will be automatically downloaded and installed.

Adding Your Own Customization

To add your own customization, use M-x customize and/or create a file ~/.emacs.d/lisp/init-local.el which looks like this:

... your code here ...

(provide 'init-local)

Tips for Using These Emacs Settings

If you want to use my settings straight out of the box, here are some things to note:

I recommend starting with a blank Emacs + Technomancy’s better-defaults package, and then dig through this repo for useful nuggets, instead of forking it directly.
The key bindings are optimized for a Norwegian keyboard layout.
Start by reading up on all the cool stuff in key-bindings.el.
You quit Emacs with C-x r q, mnemonic Really Quit.
Find file in project with C-x o, in dir with C-x C-f, recent with C-x f
Add your user- and project-specific stuff in .emacs.d/users/[machine name]/*.el
C-h is rebound to backspace, like in the shell. Get help on F1 instead.
Autocomplete with C-. (autocomplete entire lines with C-:)
expand-region is your friend. Find its bound key by doing F1 f er/expand-region
Undo with C-_ and redo with M-_. Watch the undo-tree with C-x u
Quickly jump anywhere in the buffer with C-ø then the starting letter of a word.
Indent and clean up white space in the entire buffer with C-c n
On a Mac, the Meta key M is bound to Command.
I recommend rebinding Caps Lock to Ctrl and use that instead of the often badly placed Ctrl key.
Watch emacsrocks.com

Survival Guide for the First Week of Emacs

When you start using Emacs for the first time, your habits fight you every inch of the way. Your fingers long for the good old familiar keybindings. Here’s an overview of the most commonly used shortcuts to get you through this pain:

C Shorthand for the Ctrl key
M Shorthand for the Meta key (bound to Cmd on my Mac settings)
S Shorthand for the Shift key

Files

C-x C-f Open a file. Starts in the current directory
C-x f Open a recently visited file
C-x o Open a file in the current project (based on .git ++)
C-x C-s Save this file
C-x C-w Save as …
C-x C-j Jump to this file’s current directory
C-x b Switch to another open file (buffer)
C-x C-b List all open files (buffers)

Cut, Copy, and Paste

C-space Start marking stuff. C-g to cancel.
C-w Cut (aka kill)
C-k Cut till end of line
M-w Copy
C-y Paste (aka yank)
M-y Cycle last paste through previous kills
C-x C-y Choose what to paste from previous kills
C-@ Mark stuff quickly. Press multiple times

General

C-g Quit out of whatever mess you’ve gotten yourself into
M-x Run a command by name
C-. Autocomplete
C-_ Undo
M-_ Redo
C-x u Show the undo-tree
C-x m Open magit. It’s a magical git interface for Emacs

Navigation

C-arrow Move past words/paragraphs
C-a Go to start of line
C-e Go to end of line
M-g M-g Go to line number
C-x C-i Go to symbol
C-s Search forward. Press C-s again to go further.
C-r Search backward. Press C-r again to go further.

Window Management

C-x 0 Close this window
C-x 1 Close other windows
C-x 2 Split window horizontally
C-x 3 Split window vertically
S-arrow Jump to window to the left/right/up/down

Help

F1 t Basic tutorial
F1 k Help for a keybinding
F1 r Emacs’ extensive documentation

Credits & Inspiration

This config is totally based on this repo by Mr. Steve Purcell. But this might diverge with time and my personal taste.

The Survival guide has been taken from the .emacs.d project of Mr. Magnar Sveen

Be Awesome

Thu, 27 Mar 2014 00:00:00 GMT

I write a lot about technical jargon even on my personal blog. For a change, this post is nowhere close to it. As time passes by my thinking and maturity level has improved. I am able to see things that were invisible to me before. I have learned to control my anger and frustration over things I should not have been upset about in the first place. Control over our actions and anger is important. These two things are very easy to loose but with practise these can become your strength. These days I have realized the worth of good health and fit body. Since the day, I started going to gym I could really feel the difference in my energy level and awareness. Software development is a really hard profession. There are numerous possibility of getting burnout. After working for three direct months from October, somewhere around January it hit me hard. I was shying away form hard issues, felt tired very soon. Then I realized that all I did in past three months is just code, code and code. Nothing else at all. Even on weekends I was busy with my personal projects. It gives a kick when you immerse yourself in programming. But if you ignore your body and mental health. It will come to bite you. Since then I started paying more attention to my health and hence started making full use of my Gym Membership. Another thing that I am trying to work on these days is to work only 9-5 on normal days. It might sound strange but if I want to maintain a healthy work life balance, this is a must. Wake up early, commute to office, give solid 8 hours of disciplined work, come back up home, relax, go to gym, watch some TV. These are simple things, but with Good impact.

One Year at Job

Sat, 08 Feb 2014 00:00:00 GMT

I joined Changer on Feb 2013. Today I completed my first year at full time employment. It has been nothing but amazing. As I get to understand, first year is the toughest. It is hard to adjust working with people, communicating properly and keeping your mind sane in lows and highs. I am very proud of the hard work I put in my projects. I did some mistakes, improved a lot as a person and a programmer. I am totally committed to try harder and do things right in the first time. Last but not the least, I would like to thank my parents, my girlfriend and my colleagues for being super supportive and nice during this time. I promise, I will make everyone very proud soon.:):satisfied: @vinitkumar

Setup Macvim for Maximum awesomeness

Fri, 03 Jan 2014 00:00:00 GMT

I have been using Vim for almost 5 years now. For some time, I even switched to Sublime text2 but I am finally back home. Well, the following guide is only for macs. Sorry GVIM users! Here is the latest screenshot of my macvim:![Macvim](/public/img/Vim. png) As you can see, it has a nice Filebrowser that is way more clean and intuitive than NERDTree. ## installation First and foremost down this build of Macvim from alloy’s fork: Macvim Unzip it and then put the Macvim. app into your applications. Follow these instructions to have the same in your Mac. First of all do this: ```sh Git clone Git@GitHub. com: vinitkumar/.Vim. Git git clone https://github.com/gmarik/vundle.git ~/.vim/bundle/vundle cd. Vim cp vimrc ~/.vimrc cp vimrc. before ~/.vimrc. before cp vimrc. bundles ~/.vimrc. bundles Vim +BundleInstall +qall

Install the peepopen app from here: [Peepopen](http://topfunky. GitHub. io/PeepOpen/).
When installed open peepopen and set MacVim as your default editor. Once you are done with these steps you have a super awesome development
IDE optimised for Python/JS/Ruby development. ##Credits Credit must be given to [@alloy](http://GitHub. com/alloy) and
[@topfunky](http://twitter. com/topfunky) for creating these wonderful
addons to Vim. Happy hacking!

2013 Year In Review

Wed, 01 Jan 2014 00:00:00 GMT

2013 is easily one of the most amazing year of my life. In January I interviewed for my current company and was offered to join them in Feb which I did. Well a lot did happen after that. It was my first Full Time job. I used to freelance as a Web/App Developer before which was fun. But I didn’t wanted to just sit alone at home and work. So I joined Changer precisely 11 months and the journey is nothing short of extraordinary. Well, I did a lot of things first time in my life last year: - Went home on a flight. Had never done it before, It’s an amazing experience. Got my B. E. degree in Civil Engineering in the same trip.

Travelled to Mumbai. Such an amazing and vibrant city. - Owned a MacBook Pro, HTC Android phone, Steelseries Headphones, Dell

monitor before the year’s end. I am a gadget freak so these things mean a lot to me.

Learnt a lot about Software development process and programming in

general. Courtesy these amazingly talented people at Office.

Bought some classic CS books such as SICP, AOCP. Even reading a couple

of chapters gives you so much insight. It is an amazing feeling.

With all the happy and not so happy moments last year, I have learnt

to appreciate life, time and importance of hard work.

I was always an optimist but now I have matured as hard working person. Well, in the technological field. This year was an amazinging one. I did

learnt a lot and grown as a developer. I am a big supporter of OSS and luckily my company has the same outlook. Here is a small lists of the projects I opened Sourced on GitHub: - Simple - Jekyll theme for hackers. Simple yet very features rich, SEO friendly, Developer oriented theme. - ldb. JS - Thin wrapper on HTML5 localStorage.

pagination. JS - jQuery Pagination plugin that is used in SocialSchools.
Node. JS-modular-demo - A sample demo out of TJ’s video that shows the way

of doing modular nodejs development. angular-team-profile - A nice team profile viewer built on AngularJS. It uses GitHub’s API as backend. Also, built an Android app for the same using Phonegap.

Node. JS-twitter: A twitter clone written with Node. JS, express and mongodb.

This was one of the nice project I did. Looking forward to refactor and rewrite this app in this month.

offline-sync: This again helps you to build HTML5 apps with offline

sync capability. - cmsplugin-fbalbum: This was my first attempt at writing Django CMS plugin. This plugin helps you to use Facebook as your media source and image upload service. So you save your valueable money and time.

crawler: Rewrote a crawler in Python, that I have written earlier.

Much cleaner and maintainable.

project boilerplate: Nodejs project boilerplate
todoapp: Todoapp built with angularjs in the beginning of year. - JSON2XML: A very handy, lightweight and efficient module written in

in Python to convery JSON data to XML. You can check all of them on my GitHub profile. [@vinitkumar](http://GitHub. com/vinitkumar) During the course of their development, collaborated with a lot of people across the globe and made some nice friendship. In everyway this year has been a really nice and special one for me and I would thank every single person for being nice to me.

Simplicity in things

Sat, 28 Dec 2013 00:00:00 GMT

I have always been a great fan of things around me that are simple to use and understand. In fact, each one of us appreciates things when they are simple. But life isn’t so simple. So what should be done?

Well, we could reduce a lot of clutter on a personal level that is invading our life.

Social Networks and Information Overload

These days I am getting upset or even irritated seeing some people posting crap on their social networks. Social networks were a great thing to share knowledge and information, but their overuse has just destroyed their true purpose. Don’t get me wrong, I have nothing against them, just that I don’t appreciate them polluting my life and making it more and more complex.

I started experiencing these things about a year ago. After using Facebook for almost 5 years (joined in 2007) I finally stopped using it actively and these days mostly use it for work purposes or social compulsion. But I don’t enjoy using them a bit. Not even a bit.

Life’s Higher Purpose

I feel life has a much higher purpose. We are here to solve problems and create a better life. Not to make it depressing or distasteful. I like meeting my friends in person, having a beer or grabbing some dinner. I don’t just want to keep liking their photos and exuberant display of their life and get bored. Hell no.

Technology Should Serve Us

I was meditating about the fact that technology is here to serve us and make our life easier. Not that we are meant to be hopeless people taking whatever technology is making us do. It really upsets me seeing that people respond so emotionally to all the PR stunts by different sets of people and do things that any sensible person wouldn’t even think about doing.

I realize a lot of people from our generation have lost touch with reality and never think deeply about anything. A political party sets up a page on Facebook and everyone goes madly running after them. Why? Because it’s the latest fad to do so? Do most of the people even understand anything about their agenda? Well, mostly they don’t even have a clue.

Moving Forward

Well, I don’t really have any hope for these people who don’t see these things, but I would be glad if anyone ponders about these things by reading this post.

Also, I would continue to take measures to stop this information overload and would strive to make my life simple, purposeful and happy to live.

Understanding JavaScript Classes: A Practical Guide to Prototypal Inheritance

Sat, 07 Dec 2013 00:00:00 GMT

Here is an interesting example for Classes in JS. Classes in JS don’t have a class keyword. ```JavaScript function Range(from, to) { this. from = from; this. to = to; } Range. prototype = { includes: function (x) { return this. from <=x && x <= this. to; }, foreach: function (f) { for(var x= Math. ceil(this. from); x < this. to; x++)f(x); }, toString: function () { return ’(‘+this. from+’.’+this. to+’)’; } }; var r = new Range(4,20); r. includes(5); r. foreach(console. log); console. log(r);

Buying New Books

Tue, 03 Dec 2013 00:00:00 GMT

In the span of two days I have ordered three books: - The Art of Computer Programming (Volume 1, 2 and 3)

SICP
The Art of Readable code These are considered best book in Computer Science and I am waiting eagerly

to lay my hands on them. I will also need to brush up my mathematics. Well, AOCP is considered the toughest book to understand so my plan is to keep reading it slowly and steadily. But I would like to complete TARC and SICP in the coming 6 months. For solving the exercise in SICP, I would use Clojure since it is the new hotness and runs on JVM. For TARC, I would be using my main programming language I code at work and work( Python and JavaScript). I hope the coming months to be exciting and informative. It is said that some decisions impact your life in a great manner and I would like this to be one of them.

One Month Hacking

Sun, 01 Dec 2013 00:00:00 GMT

After a lot of reflection on what I have achieved in the last year, I have stumbled upon one fact: I need to hack a lot more on Python and JavaScript. These are the two main languages I am comfortable with, and almost all my projects and official work are done with them.

Well, here are some small ideas about how I am going to achieve this:

Read a lot of good code. I will spend at least 1 hour every day reading some really awesome Python code.
Write a lot of commonly used utilities in Python. For example: Automate at least one of the tasks I do daily using Python.
Read Django documentation and toy with it.
Write PEP8-compliant code.

These were the ideas for Python. Now for JavaScript:

Give a solid foundation to my understanding of prototypical inheritance in JavaScript.
Write a lot of Backbone and some really good jQuery code.
Read some really good code and write some CoffeeScript as well.
Learn to write good unit tests in Jasmine and Mocha.

New Theme For My Blog

Sat, 30 Nov 2013 00:00:00 GMT

So this week, I wrote a new theme for my blog. One big reason was that using theme created by others were not fitting my needs and I was not inspired to write anymore. This was odd because in general I love writing posts on my blog. I felt the design was taking too much attention and the content has taken a back seat. There are few good things about this new theme I created: - More emphasis is given to the content - Good fonts has been applied and it looks pretty on all devices. - The structure is pretty simple and there are mainly three tabs. I like it the way it has come up, though some more improvements such as better responsive navbar and more SEO fields would make it way soon.

I Have Grown

Fri, 15 Nov 2013 00:00:00 GMT

Last few months has been really great for me. I think I am starting to grow as a developer and I know now how important is to keep performing at a certain level. The change started occurring when I gave up my comfort zone and started doing front-end mainly. It was a bit difficult in beginning to understand a design from a designer’s perspective and to convert it into running efficient code. I also know now that everything is important and every contribution you do in a company is worthwhile and it is worth putting all your energy in doing whatever you are doing. Now, I am looking forward to get expert level knowledge in whatever stack/technology I get to work on. One need to be always learning and improving. I am definitely more focussed now and my goal is to do some really nice work on the products I work on. Recently, I made the main website of your product [Socialschools](http://www. socialschools. nl/en/) with my very talented designer colleague Robert. It was real fun converting his great design into pixel perfect and functional website. I enjoy writing every line of code that I get to code because this is what I love to code. P. S. I am a Civil Engineer by education, but have always loved computer so naturally was inclined to write softwares. That’s it for now. Will post more about it later sometimes. You can follow the latest on twitter if you like my posts or what I say. [@vinitkme](http://twitter. com/vinitkme).

Life At A Startup

Tue, 02 Jul 2013 00:00:00 GMT

Last few months has been really exciting for me. Since, I joined [Changer](http://changer. nl) on 1st February. Here are some things I learnt in these 5 months: - I should try to learn and own the stack I am working on. Trying to do a lot of things at a time is not going to help much.

Contributing a lot to open source is a good thing and I am lucky my company encourages me to do so.
I should write a lot of code and read a lot more. I should invest time in learning and understanding my product. - I should think about code quality and maintainability before I write a single line of code. It is tough things to get right at first, but with hard work I could achieve this.
Having good understanding and relationship with the people I daily work with is important. It is must to have a smile on my face.
I must have fun with what I do. Period!

This Could Be Some Plan

Fri, 21 Jun 2013 00:00:00 GMT

I recently read a blog by Jeff Atwood that there is no such thing as a “Rock-star programmer.” These are people who can write cleaner code, refactor faster than anyone else, write a lot of tested code and follow good methodology. This means each one of us has scope to get better as a developer.

I am in my first software development job and there is a lot of scope for me to improve and get better. Obviously this is not going to happen overnight and I need to work hard to achieve this.

Here is my plan:

For JavaScript server side, read Madhu’s code and learn
For JavaScript client side, read Ruben’s code and learn
For Python, read code from good projects like Django
Write loads of code in NoSQL goodness (MongoDB)
Incorporate good software development practices
Have a good foundation with algorithms and space-time complexity
Acquire a good grasp of the theoretical aspects of JavaScript and Python
Write a lot of tested and RESTful APIs
Write tons of open source software
Spend an hour on IRC everyday
Work on a crazy project that is impossible to achieve
Work more on automation and deployments
Estimate, organize and plan my work well in advance

Well, these are kind of my strict TODO list. At this moment, I think I have a decent understanding of technology and software development process. But, I am far from being a really good developer. There are loads of things to learn and I am really excited about the process.

Professional Ethics: 15 Principles for Success in Work and Life

Sun, 16 Jun 2013 00:00:00 GMT

Work has a really important role in anyone’s life. I feel there are some things that really help us do our work nicely. - Arrive on time. Don’t be late without giving a heads up to the other party. - Think logically before making any decision. - Keep the communication lines open. - If you are facing a difficulty admit it, don’t let your ego come in between. - There are always things that could be difficult, persistent hard work is the only way to crack them. - Don’t fall victim of easy goals, work with full passion on whatever you have decided. - Don’t think much about other things, just concentrate on your work. ## Most important things: - No work is too small, everything teaches you something new. - Life is too small to waste on useless arguments. - Keep your mouth shut when you don’t have something useful to contribute. - Read books, improve your skills. - Challenge your limits. - Read well, write well.

Maximizing Productivity: A Developer's Guide to Time Management and Focus

Sat, 15 Jun 2013 00:00:00 GMT

These days I had a great time working on some pretty good projects in both office and home. I will talk about my personal projects for obvious reasons. Well, the primary goal currently is to fix the existing projects, test them and add CI support for all of them. This is single most important thing as of now as these measures improve the code quality. Also, I am working on different projects and languages so it might be little tough to adapt and plan my work. Here is what I have planned. ## How to get things done?

Work in sprint of 30 min + 3 minutes break. ( No distractions+ no phone calls+ no messaging) Do all those in this 3 min break. ## How many of these sprints? - 16 of them in a 9 hours office time. with 18 breaks in between.

Be religious about the count. ## When to plan a day and how to plan?

Plan one night before the day and also give priorities to new issues or request from Bitbucket, GitHub. ## What shouldn’t be done? - Useless arguments. - Dart Games. - Facebook. - Twitter - Time-pass stuff in Skype. # How to track my day and goals: - Use toggle religiously and also Use Omnifocus. - Omnifocus ## For Goals as Projects: - Milestones as an abstraction of the the strict todolists:
Todo Lists could be the GitHub Issues. Such links could be passed in the omnifocus App. ##Home schedule: - Morning: Gym + Breakfast - Evening: Dinner + 3 hours of self study in the same time + break as work. - Learn something new or re learn something that you forgot. - Experiment as much as you, Think, brainstorm. Write every idea that comes in your mind. Create an issue of the idea. Learn, Work, Debug, Iterate!

My Current Projects

Tue, 04 Jun 2013 00:00:00 GMT

These days I was busy working on an a project called as Node. JS Twitter. As the name suggest it is a twitter clone written on Node. JS. Right now it has following functionalities: * Login via Facebook and GitHub

Tweet Add, Modify, Delete
Comment on Tweet
Favorite a Tweet
See own and another user’s profile
Follow another User ###Here are some screen-shots:

I am also planning to add all other features present on twitter one by one. Next would be dashboard(timeline), personal profile, retweet and hashtags. These features might seem simple but most of them are not that simple and requires some good effort. Anyways, you can test it here: ``` sh $ npm install nwitter $ npm start ``` Then open your browser and open `http://localhost:3000`.

My Setup

Sun, 26 May 2013 00:00:00 GMT

I am doing The Setup interview for myself. It is basically based on these four questions: - Who are you and what do you do?

What hardware do you use?
And what software?
What would be your dream setup? So here it goes: ### Who are you and what do you do? Hello, I am Vinit and work as a software developer at this awesome Dutch startup,[Changer](http://changer. nl). I mostly write code in JavaScript and Python. ### What hardware do you use? I use a MacBook Pro, Mid 2009, with 8 GB RAM and 256 GB SSD. I use

30-inch BenQ Monitors, apple wired keyboard, Logitech GT400 at work. At home, I have a 22-inch Dell monitor with same keyboard and mouse. I use Steelseries Headphones for listening to Music. For storage and backups, I use a Western Digital 512GB Hard disk. I also have an old Dell laptop with Windows7 and Ubuntu on it. I have an HTC Desire X as my mobile phone with Android Jelly Bean. I like this phone a lot and it does almost everything I require without burning a hole in my pocket. ### And What Software? I use OS X Mavericks as my primary operating system. Well here is the list of Software I use: For writing code, I only use Macvim. For browsing I use Chrome, firefox, safari and IE (for testing mostly on VM). For running other OSes I use Virtualbox. I love [Dash](http://kapeli. com/dash). They are really awesome way to read documentation of various stacks. For tweeting I use default twitter client on both Mac and Android. I think they are pretty good. For music, iTunes suffices though I do listen to Winamp too. My shell consists of a highly optimised Zsh configuration. For Django related work I use PG Commander to view databases. For time tracking I like toggl(https://www.toggl.com/). ### What would be your dream setup? My dream setup would be couple of Big 30-inch monitors. I would also love a room with library and a nice dark corner to work.

Single Machine Work-flow

Tue, 07 May 2013 00:00:00 GMT

Benefits

More focus, less distraction
Personal productivity improvement
Skill developed for handling a lot of things with fewer resources effectively
Get better at typing and using Mac more productively

How to:

Use 75% to 100% code window in Sublime when needed
Use full browser window
Music and everything else is minimized
Distraction free mode in Sublime when required
Use different desktops for coding, shell and browser

Refrain from these:

Don’t use a monitor to break this rhythm
Don’t use a monitor unless you need to show something that can be shown on laptop

Best Practices for Managing Open Source Projects on GitHub

Tue, 30 Apr 2013 00:00:00 GMT

In last couple of days, I noticed there was no good planning for my personal projects and there were lots of loose ends. So I finally cleaned up my GitHub. Here are some of ground rules for projects on GitHub: - Don’t open source a project until the project has got unit test, wikis and sample application (if it is a application project) hosted. - Integrate CI like travis and jenkins with all of them. - Do all the immature, experimental projects on Bitbucket. - Write good, clean, pragmatic code in the projects on GitHub. - Look for bugs and spend more time on projects seriously. - Strictly follow Git-Flow on all your projects. Blog about your latest work or maintain the wiki for the project every work. At the end of week review your work.

Django plugin open sourced

Mon, 29 Apr 2013 00:00:00 GMT

There are lot of useful plugins for Django CMS. Well, this plugin let you use the images from a Facebook Album. Currently it supports fetching images from Photo Album of a Facebook Page. All you need to do is to put Facebook Album URL, Access-token and the album name in the plugin fields and you will get a nice thumbnail in the intended place and once clicked big images will open in carousel effects. Sounds nice, take a look at the screen-shots below. - Entering the details in plugin form:![Admin Page](http://vinitcool76.GitHub. io/images/admin. png) - Thumbnail view of plugin:![Small View] (http://vinitcool76.GitHub. io/imagessmallview. png) - Image slideshow in carousel![Carousel](http://vinitcool76.GitHub. io/images/bigview. png) #installation installation is dead simple. First start your virtualenv $ workon sample (sample)$ pip install cmsplugin-fbalbum You might need to do this if you are getting some sort of database error. Python manage. py syncdb Python manage. py migrate In case you face any problems, file issues and if you want to contribute take a look at the existing issues and send a pull request.

Django plugin and Google command line project open sourced

Sat, 27 Apr 2013 00:00:00 GMT

Maintaining and contributing to an Open Source Project is a very important part of a developers life. Luckily, I am in a Company that gives me full liberty to contribute and in fact we have a Open Source day(Friday) where we could open source reusable components of project we have been working on to the open source audience. This is plain awesome, because not only it encourages a healthy culture of giving back to the community, also it improves the overall quality of the project as you just do not open source anything without getting it better. With that said, I have open sourced two of my projects: [cmsplugin-fbalbum](https://GitHub. com/vinitcool76/cmsplugin-fbalbum): This is a Django-cms plugin that gives the end user to showcase the photos from their Facebook album without going through any code. Just enter the album name, album URL and access-token and you are good to go. It is also available to everyone on pypi, In order to install just do:

pip install cmsplugin-fbalbum
``` It is under heavy development and still in beta, but can be used. Any sort of contribution is welcome. [googlecl](https://GitHub. com/vinitcool76/googlecl): It is another dear project of mine, it was previously being developed by Google Engineer, Tom. H.Miller. Since he is quite busy nowadays and could not contribute actively, I have decided to maintain this project on GitHub and add features/bugfixes and refactoring. I am happy to have these two projects in progress and will open source
more of my stuff in future. Though I regret not blogging that often these days.

My First Flight

Sun, 07 Apr 2013 00:00:00 GMT

So finally, I am going on a week-long vacation, and it has finally begun. On an Air India flight to Delhi and from Delhi to Ranchi. Well, this vacation is special for a lot of good reasons. First of all, this is my first flight. Also, this is my first vacation since I started working at Changer Technologies, Pune.

I have never been to Mumbai and Delhi before, so on this trip I will be visiting both of these places. It has been so long since I have been at home, and out of everything, I miss my home’s food and family the most.

Well, according to me, there is just one way to live life, and that is to live life to the fullest. Work hard and go on vacations. Spend good time with family and friends. There are not many chances we get to do those in a lifetime. So, live it to the fullest while it lasts.

Building a Twitter Clone with Node.js: A Learning Project

Wed, 27 Mar 2013 00:00:00 GMT

I am thinking of making a Twitter-like application as a learning exercise to get better at Node.js. It will be on the usual Node.js-based stack, since I am actively learning that now. More details will be blogged as I progress.

If you are interested in collaborating or discussing, contact me here.

Edit: I completed the Node app for Twitter. It is on my GitHub. You can check it out on my GitHub.

@vinitkme

Linux to Mac

Sun, 24 Mar 2013 00:00:00 GMT

A lot of things have changed recently. I converted from a hardcore Linux user to Mac lover. I got a high-end MacBook from the office.

There are quite a few reasons for my fondness for Mac:

The OS X is quite good and amazingly stable.
UI and UX are quite good once you get used to them.
Almost every application and tool under the sun is available to you.
No messing up with hardware, just connect and play.
Awesome battery life—I could easily get 8 hours of battery backup with this sweet machine.
13-inch is an awesome form factor.

Also, I recently got myself an HTC Desire X Android smartphone. It is a lovely piece of hardware. Not big or bulky. At 4 inches, the screen gives me enough screen real estate to do whatever I need to do. The camera is good as well. All together, I am quite satisfied with my phone. Did I mention Beats Audio? It is an excellent addition to my phone. I spend quite some time traveling to the office, and it feels great to listen to music while traveling.

Though I still love my 2-year-old Dell and Nokia E5. Some repair and polishing are required, and I will surely give them their due at the right time.

I love my hardware, and doesn’t everyone else too?

From Chrome Extensions to Career: My JavaScript Journey

Sun, 24 Mar 2013 00:00:00 GMT

I started programming JavaScript seriously in September 2012, and I never wondered that it would affect my life so much. Well, it started with me working on developing a Chrome Extension for an e-commerce/social media app. Chrome is quite different for development. There are lots of APIs to learn, and there are quite a few security restrictions. Also, there is only one language that you can use to develop it: JavaScript.

There are quite a few things I learned programming JavaScript:

Think before you code; think about the whole problem at once.
Keep code clean and use a modular structure.
Use linting and follow good guidelines given by experts.
Read some good books and be aware of what you are getting into.

Today I work as a Software Developer at an awesome Dutch startup Changer.

Vinit Kumar

New Blog After a Hiatus

What Happened

Why I Stepped Away

What Changed

What’s Next

Closing Thoughts

json2xml v6.0.1: 29x Faster with Native Rust Extension

Why Rust?

The Rust Extension Architecture

Automatic Backend Selection

Handling Edge Cases

CI/CD Setup

Benchmark Results

Installation

What I Learned

Building json2xml Across Three Languages in One Day

Day 2 Updates (Jan 15)

json2xml-go Improvements

json2xml-zig Improvements

The Python CLI (json2xml-py)

What I Built

The Go Port (json2xml-go)

Features Ported

Production-Ready Touches

The Zig Implementation (json2xml-zig)

What It Includes

Benchmarks: The Fun Part

Key Findings

AI-Assisted Development

Lessons Learned

What’s Next

How to Be a Good Programmer in the Age of AI

Introduction

Don’t Skip the Fundamentals

A Practical Workflow for AI-Assisted Development

Read Good Code and Build Judgment

Know AI’s Strengths and Limits

Be Honest About Attribution

The Competitive Advantage

Conclusion

Related AI Posts

Hello 2026

The 25x Speedup: Why Python Performance Rules Matter

The Seven Golden Rules

The Test Case: Batch Signal Processing

The Bad Implementation

The Good Implementation

Performance Results

Why These Rules Matter

1. No Python Loops

2. No Python Objects

3. Batched Operations

4. Preallocated Buffers

5. Mask-Based Logic

6. No Conversions

7. No I/O

Real-World Impact

When to Apply These Rules

Key Takeaways

Conclusion

Django CMS Fellows & Community Annual Report 2025: A Year of Extraordinary Contributions

About the Django CMS Fellowship Program

🌟 Community Collaboration: The Heart of Open Source

Top Community Contributors

Highlighted Community Contributions

All Community Contributors

🐛 Community Issue Reporting

Top Issue Reporters

Notable Issues That Drove Improvements

All Community Issue Reporters

Community Statistics Summary

Fellow Contributions

Vinit Kumar (@vinitkumar)

Key Contributions

Notable Pull Requests

Fabian Braun (@fsbraun)

Key Contributions

Notable Pull Requests

Repositories Impacted