DEV Community: Jordan Tauscher

# EIS.js: The Tiny State Store That's Making Waves in 2025 🌊

Jordan Tauscher — Fri, 05 Sep 2025 06:45:31 +0000

State management in web applications has long been dominated by heavyweight solutions like Redux, MobX, and Zustand. But what if I told you there's a new player in town that's both incredibly powerful and refreshingly simple? Meet EIS.js a tiny, framework-agnostic state store that's changing how developers think about state management.

What Makes EIS.js Special?

EIS.js is a tiny, framework-agnostic state store for the web that's simple, reactive, and immutable, working seamlessly with vanilla JS, React, Vue, Svelte, and Node.js. But don't let its small size fool you – this library packs some serious features into just a few kilobytes.

Core Features That Stand Out

🔒 Deep Immutability by Default
State is always frozen to prevent accidental mutations, with recursive freezing of all nested objects for deep immutability. No more debugging mysterious state mutations!

⚡ Modern Cloning Strategy
Uses structuredClone if available, falls back to JSON.parse(JSON.stringify(...)) to ensure state updates are truly immutable. This means you get the best performance on modern browsers while maintaining compatibility.

🎯 Dead Simple API
Only three methods: get, set, and subscribe. That's it! No complex reducers, no boilerplate, no learning curve.

Latest Features & Improvements

The recent updates to EIS.js show a library that's maturing rapidly:

Enhanced Error Handling

New _isSerializable helper for better error handling means you'll get clearer feedback when something goes wrong with your state updates.

Improved Robustness

Recent fixes ensure that _freeze now properly handles arrays and already frozen objects, and doesn't attempt to freeze top-level or nested primitive data types.

Developer Experience Improvements

The set method now passes a cloned state to updater functions (no need to spread state into a new object before), making your code cleaner and more intuitive.

Real-World Usage Examples

Vanilla JavaScript

import eis from '@taujor/eis';

const [get, set, subscribe] = eis({ count: 0 });

// Subscribe to changes
const unsubscribe = subscribe((state) => {
  console.log('State changed:', state);
}, true);

// Update state
set({ count: 1 });
set((state) => ({ count: state.count + 1 }));

// Get current state
console.log(get()); // { count: 2 }

React Integration

import { useEffect, useState } from 'react';
import eis from '@taujor/eis';

const [get, set, subscribe] = eis(0);

function Counter() {
  const [count, setCount] = useState(get());

  useEffect(() => {
    const unsubscribe = subscribe((newState) => {
      setCount(newState);
    }, true);

    return unsubscribe;
  }, []);

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => set(state => state + 1)}>
        Increment
      </button>
    </div>
  );
}

When Should You Use EIS.js?

EIS.js shines in several scenarios:

Small to Medium Apps: Perfect when Redux feels like overkill
Framework Agnostic Projects: Works everywhere without vendor lock-in
Learning Projects: Minimal API makes it great for understanding state management
Performance-Critical Apps: Tiny bundle size and optional dev mode for production optimization

Performance Considerations

Like any tool, EIS.js has trade-offs. Deep cloning and freezing can be slow for very large state objects, so it's recommended to keep them small or use multiple local stores instead of a single global store. However, the new dev mode option (eis({your: "state"}, {dev: false})) disables cloning/freezing in production for better performance.

The Bottom Line

In 2025, developers are increasingly favoring simplicity over complexity. EIS.js represents this trend perfectly – it gives you powerful state management without the cognitive overhead of larger libraries.

Whether you're building a simple dashboard, a complex SPA, or experimenting with new frontend frameworks, EIS.js offers a refreshing approach to state management that just works.

Getting Started

npm install @taujor/eis
# or
yarn add @taujor/eis

Or try it via CDN:

import eis from 'https://unpkg.com/@taujor/eis/eis.js'

Ready to simplify your state management? Give EIS.js a try – your future self will thank you for choosing simplicity over complexity.

Have you tried EIS.js in your projects? Share your experiences in the comments below! 👇

Links:

EIS: A Tiny, Framework-Agnostic State Store for the Web

Jordan Tauscher — Fri, 29 Aug 2025 11:22:54 +0000

EIS: A Tiny, Framework-Agnostic State Store for the Web

Managing state in web applications can quickly become complex, especially when dealing with immutability and reactivity. Enter EIS a minimal, framework-agnostic state store designed to be simple, reactive, and immutable. Whether you're building a small app or need a lightweight solution for state management, EIS works seamlessly with vanilla JavaScript, React, Vue, Svelte, and even Node.js.

Why EIS?

EIS is built with simplicity and reliability in mind. It enforces immutability by deep-freezing state, ensuring your data remains predictable and safe from accidental mutations. With just three core methods (get, set, and subscribe), it’s easy to integrate and use, making it perfect for projects where you want to avoid the overhead of larger state management libraries.

Key Features

Immutable State: State is always frozen, preventing accidental changes.
Deep Freeze & Clone: Recursively freezes nested objects and uses structuredClone (or falls back to JSON methods) for true immutability.
Simple API: Only three methods to learn—get, set, and subscribe.
Reactive Updates: Subscribe to state changes and react instantly.
No Dependencies: Self-contained and lightweight.

Installation

Get started in seconds:

npm install eis
# or
yarn add eis

Or include it directly in your project:

import eis from 'eis';

Example Usage

Here’s how easy it is to use EIS in a React component:

import { useEffect, useState } from 'react';
import eis from 'eis';

const [get, set, subscribe] = eis(0);

function Counter() {
  const [count, setCount] = useState(get());

  useEffect(() => {
    const unsubscribe = subscribe((newState) => {
      setCount(newState);
    }, true);
    return unsubscribe;
  }, []);

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => set((state) => state + 1)}>Increment</button>
      <button onClick={() => set((state) => state - 1)}>Decrement</button>
    </div>
  );
}

Use Cases

Simple State Management: Ideal for small to medium apps.
Reactive UI Updates: Works with any UI library.
Debugging & Testing: Clear error messages and predictable state updates.

Limitations

No support for circular references or functions in state.
Performance overhead for very large state objects (keep them small or use multiple stores).

Upcoming Features

Lazy cloning/freezing for better performance.
Automatic state merging with an update method.
Comprehensive documentation and tutorials.

Conclusion

EIS is a powerful yet minimal tool for managing state immutably and reactively. Give it a try and star the repo if you find it useful! Contributions and feedback are always welcome.

🔗 GitHub Repository
🌟 Star the repo if you like it!
💬 Share your thoughts or suggestions in the comments.

How to Set Up SSH for GitHub on Linux: A Step-by-Step Guide

Jordan Tauscher — Fri, 29 Aug 2025 09:30:40 +0000

How to Set Up SSH for GitHub on Linux: A Step-by-Step Guide

If you're using GitHub on Linux and want to push or pull code in the most ergonomic way, SSH is how it's done. Since GitHub deprecated password authentication, SSH is now the standard for secure, passwordless Git operations.

In this post, I'll walk you through setting up SSH for GitHub on Linux, so you can push and pull code seamlessly.

Why Use SSH?

No passwords: No need to enter your credentials every time.
More secure: SSH keys are encrypted and harder to crack than passwords.
Easier workflow: Just git push and git pull without authentication prompts.

Step 1: Check for Existing SSH Keys

First, check if you already have an SSH key:

ls -al ~/.ssh

If you see files like id_ed25519 and id_ed25519.pub (or id_rsa and id_rsa.pub), you already have a key pair. If not, proceed to generate a new one.

Step 2: Generate a New SSH Key

Run the following command, replacing the email with your GitHub email:

ssh-keygen -t ed25519 -C "your_email@example.com"

Press Enter to accept the default file location.
Optionally, set a passphrase for extra security.

Step 3: Add Your SSH Key to the SSH Agent

Start the SSH agent and add your key:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Step 4: Add Your SSH Key to GitHub

Copy your public key:

   cat ~/.ssh/id_ed25519.pub

Go to GitHub → Settings → SSH and GPG keys
Click New SSH key, paste your key, and save.

Step 5: Change Your Remote URL to SSH

In your repo directory, run:

git remote set-url origin git@github.com:<your-username>/<your-repo>.git

Replace <your-username> and <your-repo> with your actual GitHub username and repository name.

Step 6: Test Your SSH Connection

Run:

ssh -T git@github.com

You should see:

Hi <your-username>! You've successfully authenticated, but GitHub does not provide shell access.

Step 7: Push Your Changes

Now you can push your changes without a password:

git push origin <your-branch-name>

Troubleshooting

Permission denied (publickey): Make sure your SSH key is added to the agent and to GitHub.
Could not open a connection to your authentication agent: Run eval "$(ssh-agent -s)" and try again.

Conclusion

Setting up SSH for GitHub on Linux is a one-time process that makes your Git workflow much smoother and more secure. No more password prompts, just seamless Git operations!

Have you set up SSH for GitHub? Let me know in the comments if you found this guide helpful!