30+ Must-See GitHub Projects of This Week!

1. Exo: Exocompilation for productive programming of hardware accelerators

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/exo-lang/exo
• 📅 Released On: 3/14/2025, 6:49:38 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

2. Psyllium, a Ruby Gem to make Fibers behave more like Threads

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/eestrada/psyllium
• 📅 Released On: 3/14/2025, 6:49:38 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

3. List of Useful Payloads and Bypass for Web Application Security and Pentest/CTF

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/swisskyrepo/PayloadsAllTheThings
• 📅 Released On: 3/14/2025, 6:12:43 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

4. Neural – A DSL and Debugger for Simpler Neural Network Development

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/Lemniscate-SHA-256/Neural
• 📅 Released On: 3/14/2025, 5:08:14 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

5. Ruby LLM

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/crmne/ruby_llm
• 📅 Released On: 3/14/2025, 5:08:13 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

6. LLM-docs, software documentation intended for consumption by LLMs

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/Dicklesworthstone/llm-docs
• 📅 Released On: 3/14/2025, 5:08:12 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

7. Deploy your stack's test data easily

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/mrsimonemms/gobblr
• 📅 Released On: 3/14/2025, 4:49:44 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

8. Detailed Feedback on Google's TS GenAI SDK

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/googleapis/js-genai/issues/293
• 📅 Released On: 3/14/2025, 2:40:20 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

9. Sesame CSM: A Conversational Speech Generation Model

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/SesameAILabs/csm
• 📅 Released On: 3/14/2025, 2:08:52 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

10. Guide to transform fragile AI agents into production-ready systems

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/orra-dev/agent-fragile-to-prod-guide
• 📅 Released On: 3/14/2025, 2:08:52 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

11. Sans UI library which supports iOS/Android/windows/macOS/Linux

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/profullstack/sans
• 📅 Released On: 3/14/2025, 2:08:50 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

Build a Hyper-Simple Website for a Local Business and Charge $500+

Imagine this: You help a local business finally get online, transforming their visibility, and they happily pay you $500 or more for a website you built in just a few hours.You feel empowered.They feel grateful.It’s a win-win — and you don’t need to be an expert to make it happen.I’ve created a complete toolkit designed to remove every obstacle and hand you a simple, repeatable system to build websites, find clients, and get paid — fast.Here’s what you get:📘 1. The Local Digital Goldmine Guide (10 Pages of Pure Value) This step-by-step guide breaks down the entire process into simple, actionable steps: Why Local Businesses Need Simple Websites: Understand the massive opportunity in your local area. The No-Code Website Formula: Build a sleek, professional site in under 2 hours using free or low-cost tools. Finding & Pitching Clients Without Cold Calling: Use non-salesy strategies to attract clients, even if you hate selling. Pricing & Upselling for Recurring Income: Charge $500+ upfront, then stack passive income with hosting and maintenance upsells. You’ll finish this guide not just feeling motivated — but knowing exactly what to do next.✅ 2. Plug-and-Play Checklist (Stay Laser-Focused) Success is simple when you follow a proven process. This checklist is your roadmap: 📍 Pre-Launch Preparation: Research businesses, choose tools, and set up your payment system. 🔍 Client Outreach: Use personalized email scripts and follow-ups to land your first paying client. 🛠️ Website Build: Follow a structured flow to build and launch your client's site. 🤝 Client Management: Communicate like a pro, gather testimonials, and build lasting relationships. 💸 Pricing & Upsells: Lock in high-paying clients, then offer ongoing services for passive income. No overthinking. No confusion. Just tick the boxes, and watch your business grow.🔑 3. Handcrafted ChatGPT Prompts (Your AI-Powered Assistant) Why struggle to write client emails or site content when AI can do it for you? These prompts will save you hours: ✍️ Website Content: Generate compelling headlines, service descriptions, and "About Us" sections. 📧 Client Emails: Draft outreach, follow-ups, and pitch emails in seconds. 📈 SEO & Optimization: Find the best local keywords, write meta descriptions, and boost site rankings. 🎨 Design & Aesthetics: Get layout suggestions, color palette ideas, and font recommendations. 💰 Pricing & Upsells: Brainstorm service packages, pricing tiers, and irresistible upsell offers. You’ll feel like you have a full team behind you — even if you’re a one-person business.👉 This Isn’t Just a Product — It’s a Transformation You’re not just buying a bundle of files. You’re buying: 🔓 Clarity: Know exactly what to do, step by step. ⚡ Speed: Build and launch sites faster than you thought possible. 🧠 Confidence: Feel equipped to approach clients and charge what you're worth. 📈 Freedom: Create a flexible, low-stress income stream from anywhere. Think about it: There are thousands of local businesses that desperately need a website.With this toolkit, you can be the person who delivers that solution — and gets paid handsomely for it.It’s not a question of whether you can do this. The question is: How soon do you want to start?🚀 One decision. One small investment. Infinite potential. Let’s build something incredible.

0x7bshop.gumroad.com

Making extra income by selling websites has never been easier—AI does most of the work for you!

No need to spend hours researching or figuring things out on your own. This step-by-step blueprint gives you everything you need:

• ✔️ A complete guide that walks you through the process
• ✔️ Detailed checklists so you don’t miss a thing
• ✔️ Pre-made ChatGPT prompts to make website creation effortless

It’s all laid out for you—just follow the steps and start earning! 🚀

Available on Gumroad - Instant Download

12. Golang to vlang source code translator

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/vlang/go2v
• 📅 Released On: 3/14/2025, 2:08:50 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

13. A solution to off-by-one errors in Racket based on XKCD

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/shriram/xkcd-3062
• 📅 Released On: 3/14/2025, 1:46:38 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

14. A healthcare platform that helps you develop high-quality compliant applications

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/medplum/medplum
• 📅 Released On: 3/14/2025, 1:46:38 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

15. Scrapbook – addon that captures web pages to local device or back end server

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/danny0838/webscrapbook
• 📅 Released On: 3/14/2025, 1:46:38 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

16. HashChain: Fast factor-based sublinear exact-match string search algorithm

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/nishihatapalmer/HashChain
• 📅 Released On: 3/14/2025, 1:18:43 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

17. Owl: Optimized Workforce Learning for General Multi-Agent in Realworld Task Auto

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/camel-ai/owl
• 📅 Released On: 3/14/2025, 12:56:02 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

18. Desktop app for data science, Python notebook with code recipes and AI

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/mljar/studio
• 📅 Released On: 3/14/2025, 12:17:09 PM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

19. No Code: Best way to write secure and reliable applications

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/kelseyhightower/nocode
• 📅 Released On: 3/14/2025, 9:28:24 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

20. Coq-of-rust: Formal verification tool for Rust

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/formal-land/coq-of-rust
• 📅 Released On: 3/14/2025, 8:49:13 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

21. I-cant-believe-its-not-webusb: Hacking around lack of WebUSB support in Firefox

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/ArcaneNibble/i-cant-believe-its-not-webusb
• 📅 Released On: 3/14/2025, 8:49:13 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

22. Cline: Autonomous Coding Agent for VS Code

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/cline/cline
• 📅 Released On: 3/14/2025, 8:33:32 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

Build a Hyper-Simple Website for a Local Business and Charge $500+

Imagine this: You help a local business finally get online, transforming their visibility, and they happily pay you $500 or more for a website you built in just a few hours.You feel empowered.They feel grateful.It’s a win-win — and you don’t need to be an expert to make it happen.I’ve created a complete toolkit designed to remove every obstacle and hand you a simple, repeatable system to build websites, find clients, and get paid — fast.Here’s what you get:📘 1. The Local Digital Goldmine Guide (10 Pages of Pure Value) This step-by-step guide breaks down the entire process into simple, actionable steps: Why Local Businesses Need Simple Websites: Understand the massive opportunity in your local area. The No-Code Website Formula: Build a sleek, professional site in under 2 hours using free or low-cost tools. Finding & Pitching Clients Without Cold Calling: Use non-salesy strategies to attract clients, even if you hate selling. Pricing & Upselling for Recurring Income: Charge $500+ upfront, then stack passive income with hosting and maintenance upsells. You’ll finish this guide not just feeling motivated — but knowing exactly what to do next.✅ 2. Plug-and-Play Checklist (Stay Laser-Focused) Success is simple when you follow a proven process. This checklist is your roadmap: 📍 Pre-Launch Preparation: Research businesses, choose tools, and set up your payment system. 🔍 Client Outreach: Use personalized email scripts and follow-ups to land your first paying client. 🛠️ Website Build: Follow a structured flow to build and launch your client's site. 🤝 Client Management: Communicate like a pro, gather testimonials, and build lasting relationships. 💸 Pricing & Upsells: Lock in high-paying clients, then offer ongoing services for passive income. No overthinking. No confusion. Just tick the boxes, and watch your business grow.🔑 3. Handcrafted ChatGPT Prompts (Your AI-Powered Assistant) Why struggle to write client emails or site content when AI can do it for you? These prompts will save you hours: ✍️ Website Content: Generate compelling headlines, service descriptions, and "About Us" sections. 📧 Client Emails: Draft outreach, follow-ups, and pitch emails in seconds. 📈 SEO & Optimization: Find the best local keywords, write meta descriptions, and boost site rankings. 🎨 Design & Aesthetics: Get layout suggestions, color palette ideas, and font recommendations. 💰 Pricing & Upsells: Brainstorm service packages, pricing tiers, and irresistible upsell offers. You’ll feel like you have a full team behind you — even if you’re a one-person business.👉 This Isn’t Just a Product — It’s a Transformation You’re not just buying a bundle of files. You’re buying: 🔓 Clarity: Know exactly what to do, step by step. ⚡ Speed: Build and launch sites faster than you thought possible. 🧠 Confidence: Feel equipped to approach clients and charge what you're worth. 📈 Freedom: Create a flexible, low-stress income stream from anywhere. Think about it: There are thousands of local businesses that desperately need a website.With this toolkit, you can be the person who delivers that solution — and gets paid handsomely for it.It’s not a question of whether you can do this. The question is: How soon do you want to start?🚀 One decision. One small investment. Infinite potential. Let’s build something incredible.

0x7bshop.gumroad.com

Making extra income by selling websites has never been easier—AI does most of the work for you!

No need to spend hours researching or figuring things out on your own. This step-by-step blueprint gives you everything you need:

• ✔️ A complete guide that walks you through the process
• ✔️ Detailed checklists so you don’t miss a thing
• ✔️ Pre-made ChatGPT prompts to make website creation effortless

It’s all laid out for you—just follow the steps and start earning! 🚀

Available on Gumroad - Instant Download

23. Gomcptest – A Go toolkit for testing LLM agents (MCP) with VertexAI

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/owulveryck/gomcptest
• 📅 Released On: 3/14/2025, 6:36:39 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

24. Automatically Enable Function Calling with Just TypeScript Objects

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/wrtnlabs/agentica
• 📅 Released On: 3/14/2025, 5:29:22 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

25. The default prefix used to be "SQLite_". (2006)

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/mackyle/sqlite/blob/3cf493d4018042c70a4db733dd38f96896cd825f/src/os.h
• 📅 Released On: 3/14/2025, 5:09:46 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

26. ESLint plugin for vanilla-extract CSS

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/antebudimir/eslint-plugin-vanilla-extract
• 📅 Released On: 3/14/2025, 4:11:31 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

27. Clojurellm-data: Clojure LLM – Dataset curation for fine tuning an LLM

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/ruped/clojurellm-data
• 📅 Released On: 3/14/2025, 3:39:54 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

28. Casual – re-imagine the Emacs UI using keyboard-driven menus

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/kickingvegas/casual
• 📅 Released On: 3/14/2025, 3:01:24 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

29. Jupyter JEP: AI Representation for tools that interact with notebooks

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/jupyter/enhancement-proposals/pull/129
• 📅 Released On: 3/14/2025, 3:01:24 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

30. Toy Operating System in Rust

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/SauravMaheshkar/os1
• 📅 Released On: 3/14/2025, 3:01:24 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

31. The "No Clear Winner" Era of Federated Microblogging

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/bevyengine/bevy/discussions/18302
• 📅 Released On: 3/14/2025, 3:01:24 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

32. A Python-based educational DSP playground

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/mozahzah/DSPylab
• 📅 Released On: 3/14/2025, 3:01:23 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

33. ArkFlow – High-performance Rust stream processing engine

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/chenquan/arkflow
• 📅 Released On: 3/14/2025, 2:11:36 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

34. CtrlSPEAK – Open-Source Speech-to-Text for macOS

• 🔗 Website: Available Here
• 📂 GitHub Repository: https://github.com/patelnav/ctrlspeak
• 📅 Released On: 3/14/2025, 2:11:33 AM
• 🗣 Join the discussion on GitHub Discussions
• 📢 Report issues or contribute at GitHub Issues

Check it out!

🎁 Download Free Giveaway Products

We love sharing valuable resources with the community! Grab these free cheat sheets and level up your skills today. No strings attached — just pure knowledge!

• Nmap - Cheat Sheet - For Beginners/Script Kiddies
• Stealth Tracerouting with 0trace – The Ultimate Cheat Sheet!
• File Compression in Terminal with the Ultimate 7‑Zip Cheat Sheet! 🚀
• Stealth Network Sniffing with This Ultimate 'Above' Tool Cheat Sheet!
• Advanced Forensic Format (AFF) Toolkit's Ultimate Cheat Sheet
• The Ultimate Aircrack‑ng Cheat Sheet: Crack Wi-Fi Like a Pro (100% Free!) 🚀🔥
• Hack Any Software with AFL++! 🔥 The Ultimate Fuzzing Cheat Sheet (FREE Download)
• Hack Like a Pro: The Ultimate Altdns Cheat Sheet for Subdomain Discovery! 🚀🔍
• Hackers Don’t Want You to Know This: The Ultimate Amap Cheat Sheet for Network Recon! 🚀
• The Ultimate OWASP Amass Cheat Sheet – Master Recon in Minutes! 🚀

More Free Giveaway Products: 🔗 Available Here

Build a Hyper-Simple Website for a Local Business and Charge $500+

Imagine this: You help a local business finally get online, transforming their visibility, and they happily pay you $500 or more for a website you built in just a few hours.You feel empowered.They feel grateful.It’s a win-win — and you don’t need to be an expert to make it happen.I’ve created a complete toolkit designed to remove every obstacle and hand you a simple, repeatable system to build websites, find clients, and get paid — fast.Here’s what you get:📘 1. The Local Digital Goldmine Guide (10 Pages of Pure Value) This step-by-step guide breaks down the entire process into simple, actionable steps: Why Local Businesses Need Simple Websites: Understand the massive opportunity in your local area. The No-Code Website Formula: Build a sleek, professional site in under 2 hours using free or low-cost tools. Finding & Pitching Clients Without Cold Calling: Use non-salesy strategies to attract clients, even if you hate selling. Pricing & Upselling for Recurring Income: Charge $500+ upfront, then stack passive income with hosting and maintenance upsells. You’ll finish this guide not just feeling motivated — but knowing exactly what to do next.✅ 2. Plug-and-Play Checklist (Stay Laser-Focused) Success is simple when you follow a proven process. This checklist is your roadmap: 📍 Pre-Launch Preparation: Research businesses, choose tools, and set up your payment system. 🔍 Client Outreach: Use personalized email scripts and follow-ups to land your first paying client. 🛠️ Website Build: Follow a structured flow to build and launch your client's site. 🤝 Client Management: Communicate like a pro, gather testimonials, and build lasting relationships. 💸 Pricing & Upsells: Lock in high-paying clients, then offer ongoing services for passive income. No overthinking. No confusion. Just tick the boxes, and watch your business grow.🔑 3. Handcrafted ChatGPT Prompts (Your AI-Powered Assistant) Why struggle to write client emails or site content when AI can do it for you? These prompts will save you hours: ✍️ Website Content: Generate compelling headlines, service descriptions, and "About Us" sections. 📧 Client Emails: Draft outreach, follow-ups, and pitch emails in seconds. 📈 SEO & Optimization: Find the best local keywords, write meta descriptions, and boost site rankings. 🎨 Design & Aesthetics: Get layout suggestions, color palette ideas, and font recommendations. 💰 Pricing & Upsells: Brainstorm service packages, pricing tiers, and irresistible upsell offers. You’ll feel like you have a full team behind you — even if you’re a one-person business.👉 This Isn’t Just a Product — It’s a Transformation You’re not just buying a bundle of files. You’re buying: 🔓 Clarity: Know exactly what to do, step by step. ⚡ Speed: Build and launch sites faster than you thought possible. 🧠 Confidence: Feel equipped to approach clients and charge what you're worth. 📈 Freedom: Create a flexible, low-stress income stream from anywhere. Think about it: There are thousands of local businesses that desperately need a website.With this toolkit, you can be the person who delivers that solution — and gets paid handsomely for it.It’s not a question of whether you can do this. The question is: How soon do you want to start?🚀 One decision. One small investment. Infinite potential. Let’s build something incredible.

0x7bshop.gumroad.com

Making extra income by selling websites has never been easier—AI does most of the work for you!

No need to spend hours researching or figuring things out on your own. This step-by-step blueprint gives you everything you need:

• ✔️ A complete guide that walks you through the process
• ✔️ Detailed checklists so you don’t miss a thing
• ✔️ Pre-made ChatGPT prompts to make website creation effortless

It’s all laid out for you—just follow the steps and start earning! 🚀

Available on Gumroad - Instant Download

💰 Earn Money with Our Affiliate Program

Want to make money promoting our products? Join our affiliate program and earn 40% commission on every sale! That means you can make anywhere between $8 to $40 per sale on average.

Join the Affiliate Program

Start sharing, start selling, and start earning! 🚀

Permalink

Clojure Deref (Mar 14, 2025)

Permalink

How I Built a Google Docs Add-On in Three Hours (Using Vibe Engineering)

So, I’m writing a book with Steve Yegge (famous for his 20 years at Amazon and Google) on how developers can use GenAI to do amazing things. The working title is “The CHOP Handbook: The End Of Programming As We Know It, and Why It Will Be The Best Thing Ever For Developers.”

We’re considering new titles like “Chat and Vibe Engineering for Professionals,” “Vibe Engineering In Production,” or maybe even “No Vibe Coding When I’m On Call” (thank you, Jessie Young!). Why the name change? Dr. Andrej Karpathy recently coined the term “vibe coding,” which has generated such a stir in the dev community.

Regardless of the title, our goal is to show developers how they can use GenAI to:

• Build things faster.
• Be more ambitious about things you can build.
• Do it alone, rather than depending on a team.
• Have more fun doing it.
• And, explore vastly larger design spaces

In December, I marveled that I used Python to do statistical analysis in a Google Colab notebook, something I had previously done for decades only using SPSS. At the time, I thought that was a huge achievement in itself. 

However, last month, I did something that made that seem trivial by comparison: I wrote a Google Docs Add-On in three hours, using AI and “vibe engineering” —the term we’re leaning into for the book.

Why “vibe engineering,” as opposed to “vibe coding?” Dr. Karpathy talks about vibe coding where you sort of turn your brain off. We’re describing something different — you don’t turn your brain off, and instead, you crank it way up, because with the help of AI, you’re solving challenging problems you could never do alone. You are using AI as another engineering tool.

I built a Google Docs Add-On in a language I barely understand, TypeScript. I’ve spent hundreds of hours in JavaScript, and maybe 20 hours in TypeScript — and I’ll be the first to admit that I barely understand most ES6 syntax.

The purpose of the Google Docs add-on was to explore the sibling of CHOP (Chat-Oriented Programming), which started jokingly calling CHOW, or Chat-Oriented Writing. (GitHub repo link at bottom of the post!)

Lessons:

• You often don’t need to understand all the code: This was the strange realization from my Python experience: “I don’t actually need to understand all of this code. For easy stuff, I visually inspect the results, and if the results look correct, we’re good.”
  
• But for some code, you definitely have to write tests. Luckily, Claude was great at it. (Honestly, I don’t understand how the tests work. It uses some mocking technique I don’t understand, using JavaScript prototype methods. I showed it to a longtime QA professional, and he instantly recognized it. All I cared about was that I could write tests that fail and pass.)
  
• You need fast feedback. What use is fast code generation if you can’t test it equally quicklyI This was a weak point for GAS. I couldn’t figure out how to run automated tests inside of GAS, and I spent two hours making it easy to push changes and reload quickly. It was time very well spent. – Errors need to be easily accessible so you can quickly copy/paste into an LLM.

Short Aside: CHOP/CHOW Reminds Me of a DevOps Joke

It’s not just CHOP and CHOW.  There’s a whole universe of activities in which you can use the same techniques for getting an AI to help you do your work.  Maybe we can express this pattern as:

• Chat-Oriented *: (Chat-Oriented Everything)
• Chat-Oriented (?<activity>+)$: the more precise regular expression (harhar)

Some of you probably realize the joke I stole there. Theo Schlossnagle had this wonderful line about DevOps. He pointed out that “DevOps is often incomplete, misinterpreted, and too isolated. It’s not really DevOps anymore, but rather…” —and then he showed a bunch of regular expressions, which was hilarious.

• DevOps: incomplete
• Dev.*Ops: meaning “Dev Everything Ops”
• (?<dept>+)Ops$: a more precise regex pattern that matches any department followed by “Ops”

Get it? DevOps, DevSecOps, MarketingDevSecOps, MarketingDevSecOpsSales, etc…

Let’s Skip JavaScript Editor Frameworks—Let’s Do a Google Docs Add-On!

Since last fall, I had been experimenting with JavaScript editor frameworks to find some way to better enable AI workflows to review and revise my text. I thought that Slate.js would be an amazing tool to create an easy editing environment. I had done some experiments, but nothing really seemed all that promising.

However, after talking to Steve on a Friday, we started running into a problem: I was getting better results using Claude to help review and revise text for the book than Steve was. In my mind, there is a very important meta observation here: CHOP and CHOW are orthogonal, but they involve the same techniques: context and prompts.

Months ago, in the CHOP domain, Steve noticed that I was getting pretty subpar results with AI-assisted coding—during our pair programming session, he showed me how much better I could get at prompting. Sometimes by prompting less, sometimes more.

In the CHOW domain, a need started becoming evident. We needed a tool that could standardize the prompt generation process so that we could both get the same results when doing CHOW.

That’s when the idea of using a Google Docs add-on came up. In his infectious and energetic way, Steve convinced me that building one was within my reach. Despite the fact that I knew absolutely nothing about them. I wasn’t sure I could pull this off.

However, buoyed by my many successes in the last couple of months, I decided to give it a try. After all, Steve was here to help me, and the payoff could be huge. We were spending so much time in Google Docs working on the book manuscript.

Just in case you don’t know what a Google Docs Add-On is, here’s a screenshot of one I use a lot for book projects.

1. The Extensions menu item is where active Add-Ons reside
2. The Sidebar that every Add-On renders — that’s essentially your UI
3. The Table of Contents Add-On I use, so it can be more like Microsoft Word auto-heading numbering
4. My CHOW Add-On, waiting to be activated!

Remarkably, in just three hours, I was able to build a functioning Google Docs Add-On. I was really, really blown away by my ability to accomplish this — I was bragging about it to almost everyone I talked with about it.

Here was the goal: Inside Google Docs, select text I wanted to review/revise/work with Claude. In my Add-On sidebar, click a button to have it generate a prompt. It would include the entire mansucript (spanning three different Google Doc files), include the task instructions, and the highlighted section being worked on. And generate a massive prompt that I could copy into Claude to review/critique/revise.

Once Again, Learn While Walking the Dog

Okay, so where do you start with a project like this when you don’t know anything?

Again, I found myself walking a dog, and as Simon Willison taught us to do, I started using ChatGPT in voice mode. I spent almost 45 minutes in this conversation, exploring two main topics.

My first question was simple: I described what I wanted to build and asked, “Is this even something that I could build as a Google Docs add-on?” I learned that they are written in Google Apps Script, which I had used almost 12 or 13 years ago. I kept asking it to prove that this was possible, and it eventually convinced me that it could indeed be done.

Once I had gained a bit of understanding, the next question came into focus: “Once I build my add-on, how do I actually deploy and use it?” ChatGPT explained that you can deploy it to the marketplace, or you can deploy it in test mode for your own documents. (It also described all the ways you can build and add on: You can build it as part of a document, or you build it so that you can use it in any document. I screwed this up a couple of times.)

In the next 20 minutes, I then asked about how one could write code not in the in-browser Google Apps Script IDE environment but on my laptop. I was surprised to learn that there is a tool called CLASP that does exactly that.

At that point, I had heard enough. I was convinced that I could build this. Let’s go!

Google Apps Script: My Second Encounter

Google Docs add-ons are written in Google Apps Script (GAS from here on). I used GAS once for one project about 12 years ago to build an email autoresponder, which still runs today. It was my first experience with writing JavaScript. You go to https://script.google.com/home/, and you’ll see an in-browser IDE. For a long time, GAS only executed an ancient version of JavaScript (ES3!!!), but now it supports ES6 (sort of).

(As much as I will complain about GAS, it is really quite remarkable. According to this article, “Apps Script is just as popular inside Google as it is among external users and developers. In fact, there are more than 70,000 weekly active scripts written by thousands of Googlers.” You can use it to add custom functions to Google Sheets and Google Docs. It enables access to the APIs of most Google properties. It’s like Visual Basic, but for Google Apps. Keep reading for caveats.)

To get started, I once asked ChatGPT to explain how to use CLASP to create a GAS project, synchronize files, and push my files. I studied the GitHub repo, reading the README and their fantastic tutorials.

I manage to get it working, so it’s time to code!

The Revelation of Augment Code

For this project, I wanted to try out Augment Code, which was absolutely awesome. In some ways, it is similar to using Claude Code. You don’t do a lot of highlighting of text. You just type what you want, and it suggests modifications to your code. To my surprise, it handled multi-file editing seamlessly—it just seems to know what files need to be changed (just like Claude Code). And it applies the code suggestions as fast (or faster) than Cursor.

This was a month ago, but the prompts I remember typing sounded like:

• Create a button that brings up a dialog box. (I then learned that `ui.alert` can have a Yes/No button—who knew?)
• Get the selection that is currently highlighted in the Google Docs editor.
• Make a new button called “Reload Sidebar”. Make a button to put something in the clipboard.

In less than an hour, I managed to get a very simple Google Docs add-on working, with a simple sidebar and a counter. It was comprised of an HTML file, which renders the sidebar, and a .gs file, which is the JavaScript that was transpiled by CLASP using TypeScript.

I couldn’t believe I was actually starting to build something that looked like a real Google Docs add-on!

My next prompt was: “Make a new button called ‘Load Document’ and store it in a global variable.”

Then the sledding got pretty rough.

Google Apps Script API Documentation Leaves A Lot To Be Desired

I actually bought a book on GAS seven years ago: “Going GAS: From VBA to Google Apps Script.” When I found myself sufficiently bewildered by how Google Docs add-ons worked, I found myself reading it again, but I got a little impatient. I started hacking around and eventually realized two things.

First, my mental model of how the Google Docs add-ons work was completely wrong. There are actually two pieces to it:

1. The front end is the HTML file, and you can run JavaScript code that you put there inside of <script> tags.
2. The back end is the GS file.

To my surprise, there is no shared memory between the two. Communication occurs via remote procedure call, triggered by using the Google.script.run API. And I’m pretty sure that the front end can only run ES3, while the back end runs something different in those .GS files— something like, but not exactly JavaScript. But Clasp allows you to write it in TypeScript/ES6l and transpiles it into those .GS files.

Where was that documented? I have no idea. (I was having lots of trouble finding documentation for things I was trying to do in GAS. And I think because there is so little documentation, Claude kept hallucinating APIs that didn’t exist. More on that later.)

But that actually paled in comparison to a much bigger problem.

Fixing The Horrible 15-Second, Six-Step Feedback Loop

The issue was that reloading modified GAS code required so many steps. I would make a change on my laptop, save the file, and push it to GAS using CLASP. And then I have to go back to my Google Docs instance, click the Extensions menu bar, and click the “Reload Sidebar” menu item.

This was really intolerable. I’m accustomed to hot code reloading in Clojure and ClojureScript, which is typical in many JavaScript environments—you save your file and see the changes immediately.

This situation felt like the opposite—it was probably 15 seconds to get feedback on my work, and so much clicking! When your AI is giving you bad API calls that don’t exist, it’s really interolable that it takes so work to determine whether your code works or not.

I spent about two hours across two days trying to get as close to a hot reload as possible. Fortunately, CLASP has a watch mode that can monitor for local file changes, which can trigger the TypeScript transpilation and push into GAS.

I eventually got it down to clicking a “Reload Sidebar” button, which was so much better than before, which required multiple clicks inside a menu item.

Now that I got a reasonable developer experience going, it was time to tackle the API documentation problem.

OpenAI Deep Research To The Rescue

I hit a brick wall because I managed to get the Google Docs add-on working for one document, but I couldn’t figure out how to deploy it so that I could use it in any Google Docs environment. I searched for help and couldn’t find anything.

I was at a total standstill. Fortunately, OpenAI Deep Research came to the rescue. The prompt:

• I have written a Google Apps Script Workspace Add-On. I have a test deployment add-on deployed: deployment ID is xxxx. How do I use it in any Google Doc?

It came back after 10 minutes and gave me almost 10 pages of instructions on what to do — here’s the ChatGPT session doc, in case this helps someone in the future. After some hacking around, I finally got it working. (Note my use of OpenAI Deep Research to find the solution, and o3-mini-high to use that knowledge to solve my problems.)

The biggest problem was that I just couldn’t find the Add-On icon! Who knew that it would show up as an icon on the right sidebar? In the screenshot at the top of the post, my icon is #4. (Where was that documented? )

Oh, I also had to use Google Deep Research and o1-preview or o3-high to figure out how to create a working “Reload Sidebar” button! (Every other attempt with any other model closed the sidebar and terminated the program before the reload finished.)

(When I told Steve this, he quipped, “I complained about GAS not getting any love back in my platform rant in 2011. It’s been 13+ years, and those pancake heads at Google still haven’t figured out that, yes, platforms really do matter. I’m sure GAS wants to do more but gets zero resourcing.” Haha. You always learn a bunch hanging out with Steve. 😆)

But once I got the add-on running inside my Google Doc, things started really cooking. Looking through the Git repo, my prompts must have looked like this:

• Create function to convert the Google Doc data to Markdown.
• Write tests for the above that could run inside Google Apps Script in the in-browser IDE. (This wasn’t great, but some tests that are inconvenient to run are better than no tests at all, because I couldn’t understand the giant JavaScript function, with lots of regular expression.)
• Concatenate multiple Google Docs together (because our manuscript spans multiple Google Docs).
• Add word count to the sidebar.
• Create a dropdown box in the sidebar to enable multiple prompts. (Wow! I barely know how dropdown boxes work!)
• Build tests for assembling the different types of prompts.
• Help me clean up the mess I made in the sidebar.html file, because I had <script> tags scattered all over the place.
• Introduce some global variables to manage persistent state.
• Remove global variables and use the Google Apps Script API for key-value pairs.

Oh, another thing I did to improve my developer experience was putting my log messages in the sidebar! Google Docs add-on logging can be cumbersome—the front end can’t log to the browser console (console.log doesn’t work), and the back end logs only show up in the in-browser GAS IDE.

The Success Moment

I started this project on a Saturday morning. Late on Sunday night, I texted Steve that I was going to do my first roundtrip using CHOW. That meant I would use my CHOW tool to highlight some text, click a button, which would take the Google Docs files and the selection to generate a prompt in JSON. It would then copy it to the clipboard, so I could paste it into Claude.

In Claude, I could critique the section, review and revise it, and then copy it back into our manuscript in Google Docs.

Here’s the screenshot I took of the Add-On, and a video of me using the tool.

The first minute shows the add-on in action; the second minute demonstrates augment code making quick usability changes while pushing it into Google Apps Script. In the third minute, I showcase how quickly the “Apply” operations occur, and in the eighth minute, I illustrate how CHOW evaluates a section, critiques it, and uses Claude to implement changes.

Another challenge I encountered with the Google Docs add-on was obtaining logging information. I utilized the sidebar to display logs, and I was thrilled when Steve successfully installed the Google Docs add-on. Having others use your extension without publishing it in the marketplace can be quite cumbersome, but he managed to clone the repository and deploy it in his environment, which was great.

I was elated that Steve successfully installed the Google Docs add-on so he could use it himself. (He gave up trying to follow the instructions, and instead cloned my repo, and deploy it in his Google environment.)

Reinforced Lessons

As I reflected on what I had accomplished with this Google Docs add-on project, I realized something important about how AI is changing the way I learn and build.

You often don’t need to understand all the code: This was the strange realization from my Python experience: “I don’t actually need to understand all of this code. For easy stuff, I visually inspect the results, and if the results look correct, we’re good.”

But for some code, you definitely have to write tests. Luckily, Claude was great at it. (Honestly, I don’t understand how the tests work. It uses some mocking technique I don’t understand. I showed it to a longtime QA professional, and he instantly recognized it. All I cared about was that I could write tests that fail and pass.)

You need fast feedback. What use is fast code generation if you can’t test it equally quicklyI This was a weak point for GAS. I couldn’t figure out how to run automated tests inside of GAS, and I spent two hours making it easy to push changes and reload quickly. It was time very well spent.

Errors need to be easily accessible so you can quickly copy/paste into an LLM: Unfortunately, GAS is not great in this regard; because errors are buried inside the in-browser GAS IDE, and console messages can’t go to the browser console. (My solution was to copy them into the add-on DOM)

An Embarrassing Moment Exposing My Lack Of Understanding Of My Code

An embarrassing moment occurred when Steve questioned a specific portion of the code, Google.script.run, asking why it was called twice. He made fun of me, suggesting I didn’t catch the LLM doing something stupid.

I promised to fix it. But I realized the next day that it wasn’t slow due to the multiple calls; the multiple calls were actually required because of callbacks. In fact, it was being called three times: once for the script call, once on success, and once on failure.

There’s a lesson here, but what it is exactly eludes me right now.

(Moreover, my attempt to use async/await to fix the “callback hell” problem didn’t work. As I mentioned, I think it’s because the JavaScript in the HTML appears must be the ES3 version of JavaScript, which dates back to the early 2010s.)

Vibe Engineering Is Amazing

For me, this represents an entirely new way of programming and writing. I was able to build a program in a language and ecosystem I barely knew. I’m using this tool nearly every day, and I couldn’t have done it without AI. I was able to:

• Build things faster.
• Be more ambitious about the things I can build.
• Do it alone rather than depending on a team.
• Have more fun doing it.
• And, explore vastly larger design spaces.

Oh, and here’s the link to the repo: https://github.com/realgenekim/chow-addon

Huzzah!

We’re Looking For GenAI/Dev Experience Reports

The Enterprise Technology Leadership Summit in Las Vegas in September will be featuring amazing experience reports — one of the focus areas is how technology leaders are using GenAI to make developers more productive! Register or submit a talk proposal here!

The post How I Built a Google Docs Add-On in Three Hours (Using Vibe Engineering) appeared first on IT Revolution.

Permalink

Repetition

Sometimes, Clojure seems to miss operations that feel like they should be in clojure.core. I'm clearly not the only one who has felt this way, as evidenced by James Reeves's medley library. These missing operations are typically simple to implement, but after rewriting them for the nth time I feel like putting them in my own library. Or maybe contributing to James's.

Today's question was how to identify duplicates in a seq. For instance, say we have a sequence of numbers with a duplicate:

(def a-seq [0 1 2 3 4 2 6])

Step 1

My first thought was that every element in the sequence needs to be compared to every other item. Indeed, if the first element is not equal to any of the sequence that follows it, then that element need not be considered again. How might that look?

I'll start with a different seq where the first element does appear again:

(def seq0 [0 1 2 3 4 2 0])

We want to avoid indexing and loops whenever possible in Clojure, as these are conceptually low-level, and can be a source of errors. Instead, we want to look in clojure.core for applicable functions whenever possible.

As with any Lisp, the 2 main functions to consider for processing seqs are map and reduce. The map operation will do something for every element in a seq, returning a new seq, while reduce will derive a single value from processing each element in a seq. In this case, we're looking for a repeated value:

(reduce (fn [result element] (or result (= (first a-seq) element))) nil (rest a-seq))
true

OK, this found the value, but which value was it?

(reduce (fn [result element] (or result (and (= (first a-seq) element) element))) (rest a-seq))
0

This could then be applied to each subsequence, of the seq, but... wow, is it clunky. The reducing function is doing a lot here, comparing if the result is true yet, and if not, then comparing the provided first element to the element being presented by reduce, returning that element if needed.

We could clean it up a little by putting reduced over the return value so that it breaks as soon as the first match is found, and using a singleton set for the equality test:

(reduce (fn [result element] (or result (and (#{(first seq0)} element) (reduced element)))) (rest seq0))

But clojure.core already has a function that does all of this, called some. The documentation even tells us that we can use a set as an "equality" test when searching a seq:

(some #{(first a-seq)} (rest a-seq))

Step 2

But now we want to do this for every sub-seq, dropping off the head each time. One way might be to use drop to remove the start of the seq, counting up:

(map #(drop % a-seq) (range (count a-seq)))
((0 1 2 3 4 2 6) (1 2 3 4 2 6) (2 3 4 2 6) (3 4 2 6) (4 2 6) (2 6) (6))

But counting the sequence, or even using map-indexed (which does the counting for you) is still getting very involved in the mechanics of processing a sequence. Is there a higher-level construct?

One mechanism is using the rest operation over and over. This might be done using reduce in some way, but fortunately the iterate function does exactly this. Except it returns an infinite series, so we just need to take the correct amount. Let's go past the end by 5 to see why we need to keep it constrained:

(take (+ 5 (count a-seq)) (iterate rest a-seq))
([0 1 2 3 4 2 6] (1 2 3 4 2 6) (2 3 4 2 6) (3 4 2 6) (4 2 6) (2 6) (6) () () () () ())

This looks good, but it's still counting the length of the seq, so we want to keep looking for a better approach.

The map function is more flexible than simply applying an operation to transform each element of a seq. It can also be used to apply an operation to a group of elements across multiple seqs. The best part about this is that it will terminate as soon as the first of the seqs finishes. So let's try using map between the original seq and the iteration. We can just return the 2 values as pairs to see what we are working with:

(map (fn [a b] [a b]) a-seq (iterate rest a-seq))

This is almost exactly what we want as the arguments for the some operation above. Each operation of the map could execute rest on its second argument, but if we start the iteration one step along, then can get the same effect without needing the extra rest every time:

(map (fn [a b] [a b]) a-seq (rest (iterate rest a-seq)))
([0 (1 2 3 4 2 6)] [1 (2 3 4 2 6)] [2 (3 4 2 6)] [3 (4 2 6)] [4 (2 6)] [2 (6)] [6 ()])

These pairs are exactly what we needed for the some operation, so let's look at that:

(map (fn [a b] (some #{a} b)) a-seq (rest (iterate rest a-seq)))
(nil nil 2 nil nil nil nil)

Step 3

This is almost done. We need to skip to the first non-nil value, which we already know we can do using some. However, some needs a function to apply whereas we don't need to do anything to the value, just use it as-is. So we can use identity here:

(some identity (map (fn [a b] (some #{a} b)) a-seq (iterate rest (rest a-seq))))
2

To look more Clojure-ey we would usually run steps like this through a threading macro, and the anonymous function can be abbreviated as well. Of course, we want this to be a function, so we can replace the use of the a-seq value with a function argument, which I'll just call s for "seq":

(defn any=
 [s]
 (->> s
      rest
      (iterate rest)
      (map #(some #{%1} %2) s)
      (some identity)))

Step 4

After all of the above, I was thinking I had something relatively nice, and maybe I should write about the process of getting to it. Hence this post. I actually included extra steps along the way, just to spell things out, though I didn't actually go through most of those steps.

While thinking of extra steps and alternatives that I could write about, I thought about comparing to Clojure's distinct function which can remove duplicates:

(distinct a-seq)

This is similar to what I needed, but instead of telling me when it found a duplicate, it skips the duplicates instead. A similarly written function would also work, but this function is a transducer, and these are probably more work than should be necessary for something relatively simple.

I'm not saying that a transducer would be difficult. They follow a straightforward template:

(defn duplicates
 ([]
  (fn [rf]
    (let [seen (volatile! #{})]
      (fn
        ([] (rf))
        ([result] (rf result))
        ([result input]
         (if (contains? @seen input)
           (rf result input)
           (do (vswap! seen conj input)
               result)))))))
 ([coll] (sequence (duplicates) coll)))

This is actually a little more flexible since it can find all of the duplicates, rather than just the first one:

(duplicates [1 2 3 4 2 4 5 1])
(2 4 1)

The transducer approach also has the benefit of only processing the seq s single time, and using memory to recall what it has seen. So instead of O(n^2) complexity, it becomes O(n.log(n)) complexity (since the hashmap insertions and lookups are logarithmic - though in Clojure they are effectively O(1)).

However, all I needed was a function that could report the first duplicate in a seq. Maybe there was some way to use distinct for that.

Let's try using map again, this time against the original seq and it's distinct version. We'll emit pairs to see what is happening:

(map (fn [a b] [a b]) a-seq (distinct a-seq))
([1 1] [2 2] [3 3] [4 4] [2 5])

It terminated at the end of the distinct version, but we can see that just at the end the two sequences differed. This will happen if there is a duplicate in the first sequence that didn't appear in the second. So we can output that one when we get to it:

(map (fn [a b] (when (not= a b) a)) a-seq (distinct a-seq))
(nil nil nil nil nil 2)

This will keep emitting values after the first duplicate is found, since the two sequences are now misaligned. Consequently we only want to return the first non-nil value from the seq:

(some identity (map (fn [a b] (when (not= a b) a)) a-seq (distinct a-seq)))
2

Giving a new version for finding the first duplicate:

(defn any=
 [s]
 (->> s
      distinct
      (map #(when (not= %1 %2) %1) s)
      (some identity)))

Wrap Up

This is a little shorter, has better complexity, and makes better use of clojure.core. I'd probably use this one instead of my first attempt.

This post also reminded me to check my assumptions. This is not the first time I've tried to explain why one approach was not as effective as another, only to show that it was better. I need to remember that.

Permalink

JWT - Authentication and Authorization with JSON web token in Clojure ring

Notes

• Code
• Buddy Auth
• JWT on Wikipedia
• JWT

Permalink

Migrating to LazyTest

I've been using the Expectations testing library since early 2019 -- over six years. I love the expressiveness of it, compared to clojure.test, and it exists because "Classic Expectations" was not compatible with clojure.test tooling. At work, our tests use a mixture of clojure.test and Expectations, but in my open source projects, I've mostly stuck with clojure.test for familiarity's sake for contributors.Being compatible with clojure.test comes at a price, though. Expectations uses macros to produce clojure.test-compatible code under the hood, so it is limited by the same reporting as clojure.test and the same potential problems with tooling that tries to override parts of clojure.test's behavior -- namely that multiple tools do not play well together, so I've had to avoid "improving" the expressiveness or reporting in ways that would break compatibility with that tooling.

Permalink

Bad data models lead to code complexity

Our last Apropos was with Alex Engelberg. Check it out. Our next episode is with Sean Corfield on March 11 (Paula had to cancel). Please watch us live so you can ask questions.

Have you seen Grokking Simplicity, my book for beginners to functional programming? Please check it out or recommend it to a friend. You can also get it from Manning. Use coupon code TSSIMPLICITY for 50% off.

Bad data models lead to code complexity

There I was, staring at a complex, nested if statement with hard-to-follow logic in each condition. What’s worse, similar logic was repeated in several places in the codebase. That was when I realized how much complexity a bad data model can cause.

An example of a bad domain model

The domain was simple. I’ll describe a similar one that is an easier example so I don’t have to explain the whole domain. Imagine a content management system for a magazine. Articles go through several stages as they are prepared for publication:

• Drafting

• Editing

• Approval

• Publication

We modeled it with several Maybe<DateTime> type. As we finished a stage, we added the time. If the time didn’t exist, it meant that we had not finished that stage yet.

type Document = {
  drafted?  : Date;
  edited?   : Date;
  approved? : Date;
  published?: Date;
};

This worked for a while, but eventually we found problems.

The first problem was that our logic was complicated and duplicated. If we wanted to know if something was in the approval stage, we had logic like this:

if(document.drafted && document.edited && !document.approved)

The second problem was that as we increased the number of documents in the database, with many releases to our software (often with bugs), we eventually got data that had impossible states. For instance, it was edited without being drafted:

{
  drafted: null,
  edited: new Date("2010-01-02")
}

How could this happen? Well, despite our checks, something slipped through. Maybe it was a bug in a prior release. Maybe it was user error. Whatever the case, it existed, and our code needed to make sense of it. That meant more if statements.

This is a bad data model. I mean that in an objective way. We can actually measure how bad it is. We can count the number of states in the domain and the number of states in the model, and see how far off they are from each other. Here is the timeline of a document workflow:

The horizontal lines represent events that divide the timeline into sections. Each section is a distinct state that the document can be in. We see clearly that there are five states a document can be in in this domain.

Our model is different. It contains for optional values, where the presence of the value is meaningful. The date is also meaningful, but in a different way. I’m going to ignore it for this analysis, even though it also could present difficulties such as if a document is published before it is drafted. We’ll just look at the presence or absence of the value.

In that situation, there are four values with two options each (present/absent), which is 2^4 = 16. So our data can represent 16 states. That means that 11 of our states are redundant, ambiguous, or invalid, because we only needed 5.

That sucks. Those unneeded states caused a lot of code complexity because our code had to map them to the domain concept. It had to deal with the ambiguity of the situation. That was the second problem I talked about (finding impossible data in the database). We could have seen this coming with some simple math.

The first problem was still there. Remember, the first problem was about the complex, duplicated logic we found everywhere. It wasn’t really because there were ambiguous states. It was more that what we stored didn’t correspond well to what we needed.

Remember, we were storing the time that we crossed each of the horizontal lines. But what we wanted to know was which green box we were in. We had to write compound conditionals to convert the lines into boxes.

Adapting the existing data model to a better one

Luckily, we can adapt this model and solve both problems with in one stroke. Remember, domain modeling is about mapping. So let’s create a function that maps the data model we have to the data model we wish we had:

function documentStatus(document) {
  if(document.published) return "published";
  if(document.approved) return "ready";
  if(document.edited) return "approval";
  if(document.drafted) return "editing";
  else return "drafting";
}

We did double-check to make sure that this does correctly map the ambiguous states to the correct states. Luckily, it was simple. We could imagine it being much more complex than this. For instance, we might have a check somewhere in the code that a document with a published date but no content is actually in the drafting stage. I have a hunch that this is where the really hairy complexity comes from—different behavior in different places in the codebase because of inconsistent logic. Either way, having a single place that defines the mapping to our desired model is a good thing. The biggest trouble with it is making sure to use it consistently.

We could then use the human-readable string representing the status in place of a bunch of booleans anded together:

if(documentStatus(document) === "approval")

instead of:

if(document.drafted && document.edited && !document.approved)

Here are the things we achieved:

• Centralized the logic for determining the status

• Eliminated inconsistencies in status logic across the codebase

• Made status checks more human-readable

• Eliminated complex conditional logic

I’d say it was a major win.

Is this a major win? Or a waste of time?

Even still, I have encountered people who think this is a waste of time. To put a fine point on it, this change was both small (in the number of lines of code it saved) and extensive (in the number of lines of code and the number of files it touched). Further, it was risky. Changing so many lines of working code could introduce bugs we couldn’t anticipate. In short, it’s high risk and it doesn’t eliminate much complexity.

When I ask them about where code complexity comes from, they say it’s from other sources—mainly business logic, user requirements, and system interactions. Bad domain models do introduce complexity, but it’s a rounding error compared to those sources.

My response is always the same: Those sources of complexity can be modeled, too. Nesting if statements is one simple tool we have to address a corner case. I’ve done it myself thousands of times. It’s extremely useful when I don’t have the time to fully understand what is happening in the codebase. Surgically adding an if where I’m certain it will be useful is a versatile tool.

But nesting ifs is a tool that breeds more complexity. The next time I or someone else needs to handle a new case, it becomes that much harder to understand, so that much more likely that we’ll add yet another if.

Modeling is the only way to rein in complexity

Look, I’m getting deep into the weeds here, and I need to bring this thread back to my intended point: There’s no way to clean up those ifs without understanding the domain. All a domain model is is an understanding of the domain expressed in code. When you express it in code, its an understand that is available to anyone who cares to read it. Domain modeling is software design. Trying to eliminate complexity without modeling is a fool’s errand. Domain modeling is a necessary skill for designing software. So we might as well get good at it.

When we talk about modeling business logic, often people hear “oversimplifying”. That is not what I’m talking about at all. Domain modeling means embracing the complexity, but identifying the structure of it, then writing that structure down in useful code. Maybe I’m preaching to the choir, so I’ll just leave it at that. If you’ve got an understanding, you can write it down. I also hope to show that there are objective measures of data model quality in my upcoming book. Modeling is a skill, and you can get better at it.

Conclusion

Code complexity is a major cost of software development. Bad data models add significantly to code complexity—when models don’t correspond to the domain, we require extra code to handle the redundant and missing cases. Cleaning up the data model can significantly contribute to reducing complexity. Even if you think that data models aren’t a major source of complexity, the sources of complexity can also be modeled. Chances are, the current models of things like business logic, user requirements, and system interactions are poor models. They’re adding way more complexity than they actually need. You can clean those up, too.

I hope to bring this awareness of poor models to the industry. Currently we’re stuck thinking about code in isolation instead of how it relates to the domain. I’d like to help fix that, which is why it’s a major theme of my book. I don’t want domain modeling to be just another abstract skill. Instead, it’s fundamental to software design. The more I research it, the more I see that it’s the real key to explaining a lot of software design advice.

Do you have any interesting stories involving domain modeling? How do you apply domain modeling in your work?

Permalink

Software Engineer at Scarlet

Permalink

Annually-Funded Developers' Update: Jan./Feb. 2025

Hello Fellow Clojurists! This is the first report from the 5 developers receivng Annual Funding in 2025. (Highlights listed on the list below - but the reports include much more).

Dragan Duric: Apple M Engine Neanderthal
Eric Dallo: lsp-intellij, repl-intellij. lsp, lsp4clj
Michiel Borkent: clj-kondo, squint, babashka, fs, SCI, and more…
Peter Taoussanis: Truss v2, Telemere v1 RC3
Oleksandr Yakushev: CIDER, clj-async-profiler and Flamebin, clj-memory-meter

Dragan Duric

2025 Annual Funding Report 1. Published February 27, 2025.

My goal with this funding in 2025 is to support Apple silicon (M cpus) in Neanderthal (and other Uncomplicate libraries where that makes sense and where it’s possible).

In January and February, I released the first version of Neanderhal that can run on Mac/Apple M!

My grant proposal: Here’s what I’ve proposed when applying for the CT grant.
I propose to * Implement an Apple M engine for Neanderthal.* This involves:

• buying an Apple M2/3 Mac (the cheapest M3 in Serbia is almost 3000 USD (with VAT).
• learning enough macOS tools (Xcode was terrible back in the days) to be able to do anything.
• exploring JavaCPP support for ARM and macOS.
• exploring relevant libraries (OpenBLAS may even work through JavaCPP).
• exploring Apple Accelerate.
• learning enough JavaCPP tooling to be able to see whether it is realistic that I build Accelerate wrapper (and if I can’t, at least to know how much I don’t know).
• I forgot even little C/C++ that I did know back in the day. This may also give me some headaches, as I’ll have to quickly pick up whatever is needed.
• writing articles about relevant topics so Clojurians can pick this functionality as it arrives.

Projects directly involved:
https://github.com/uncomplicate/neanderthal
https://github.com/uncomplicate/deep-diamond
https://github.com/uncomplicate/clojure-cpp

First, I set to the task of tidying up the existing versions of Uncomplicate libraries (Neanderthal, Deep Diamond, etc.) to bring them up with the latest versions of native libraries, cuda, etc., and to fix some outstanding issues/bugs that might complicate work on Apple M support. After that, it was time for the main task, the beginnings of Apple M support.

The plan was to buy an Apple M2/M3, but in the meantime the nice Clojurians from Prague donated a used (but fantastically beefed up) MacBook Pro Max M1, so this was covered quickly!

I explored OpenBLAS as the first choice (the other is Apple Accelerate), as it can also work on Linux and Windows, and could be immediately beneficial to all users and easier to start with (I didn’t need to switch to Apple yet).

I implemented the OpenBLAS engine for the part of functionality that was supported by JavaCPP’s openblas preset. A lot of critical functionality was not present there (although some of it was there in the openblas itself), so I jumped at the opportunity to learn some JavaCPP preset building, and improved JavaCPP’s OpenBLAS. After a bit of experimentation and lot of waiting on the compiler and github tools, this is now contributed upstream.

Next, I returned to the pleasant part of work - programming in Clojure - and completed the first Neanderthal engine that runs in Apple M Macs. This covers the core and linalg namespace, because this is what OpenBLAS covers. The rest of Neanderthal functionality is waiting for me to explore Apple Accelerate, and to create engine based on that.

I managed to release Neanderthal 0.53.2, which enables Clojurians to use this on their Macs, just in time for this report.

I hope they’ll have immediate benefits, and have fun doing some high performance hacking on their Macs.

Many thanks for CT for sponsoring this work!

Eric Dallo

2025 Annual Funding Report 1. Published February 27, 2025.

In the first two months of sponsorship I could work on so many things related to IDE development which made me really glad of this sponsorship! :heart:

I spend most of the time improving the Clojure development on IntelliJ, improving both clojure-lsp-intellij and clojure-repl-intellij plugins releasing 2 major extremally important versions. The IntelliJ Clojure development using those plugins are way better and mature, please test and give feedback!

clojure-lsp-intellij

The 3.0.0 major version was a refactor on most of the plugin to use lsp4ij, an OSS plugin for IntelliJ which makes easier to code and use LSP features, so this integration removed tons of code from this plugin that I needed to implement manually (and some had some bugs) and added support for lots of missing features that I didn’t even plan to add. The lsp4ij plugin is used by multiple languages already which makes this plugin more resilient and stable. Check it out the call hieararchy feature on the image.

Kudos to @angelozerr for the help during lsp4ij integration on their side.

3.0.0 - 3.1.0

• Fix brace matcher to insert closing brace for some missing cases.
• Add imcompatible tag with Cursive and Clojure-Kit plugins.
• Integrate with lsp4ij, a LSP client plugin, removing lots of logics from this plugin and fixing multiple bugs and issues. Fixes #63, #61, #59, #57, #53, #36, #21, #9, #5
• Drop support for older intellijs, supporting 2023.3 onwards.
• Bump clj4intellij to 0.6.3.
• Fix code lens references not working when more than a project is opened. #67
• Fix Settings page exception when more than a project was opened and closed.
• Fix comment form complain about missing paren.
• Improve server installation fixing concurrency bugs + using lsp4ij install API.

clojure-repl-intellij

This 2.0.0 major release included multiple fixes and new features like the new _Inlay hint eval result + _REPL syntax coloring.

Kudos to @afucher for the help on some of those features.

2.0.0 - 2.2.0

• Add icons of REPL commands to REPL window (clear and entry history navigation). #99
• Drop support of older IntelliJ versions (2021/2022). Now requires minimum IntelliJ 2023.3 (Build 233)
• Fix namespace-not-found error handling. Now shows a message to the user. #107
• Add eval inlay hint support. #106
• Add action to interrupt evals on the REPL session (shift alt R + shift alt S). #104
• Add color settings page for customization of some tokens.
• Add default name for RunConfigurations instead of save as Unnamed. #123
• Add REPL syntax highlight. #18
• Fix eval defun at cursor action error. #121
• Create view error on test error. #128
• Block backspace on repl input.

clojure-lsp

clojure-lsp is the base for all Clojure language handle logic and analysis, so lots of fixes and improvements are made all the time.

2025.01.22-23.28.23 - 2025.02.07-16.11.24

• General

  • Bump clj-kondo to 2025.01.16
  • Bump lsp4clj to 1.11.0.
  • Add semantic version sorting in completion lib versions. #1913
  • Fix internal error in range formatting. #1931
  • Drop support for jdk 8. #1942

• Editor

  • Change simple keyword completion to return all known keywords. #1920
  • Return textEdit to CompletionItems to fix completion in Zed #1933
  • Restrict linked edits to namespace aliases only, and fix a few related issues #1947
  • Add :hover :hide-signature-call? settings option to disable showing the surrounding call. #1954, @NoahTheDuke
  • Revert #1933, which caused a regression on completion adding extra text.
  • Fix fetching libs exception causing progress notification to be stuck. #1958

• API/CLI

  • Add :project-and-shallow-analysis type to dump command
  • Add :diagnostics to dump command output (successor of :findings)

lsp4clj

lsp4lj is the base of clojure-lsp, it’s the layer that has all the LSP communication layer, making easy to build LSP clients/servers of any language in Clojure.

v1.11.0

• Add a :response-executor option to control on which thread responses to server-initiated requests are run, defaulting to Promesa’s :default executor, i.e. ForkJoinPool/commonPool.
• Fix work done progress notification to allow nullable message.

clj4intellij

clj4intellij is a lib that makes possible to code IntelliJ plugins in Clojure, it’s used by both clojure-lsp-intellij and clojure-repl-intellij plugins.

0.6.0 - 0.6.3

• Add unregister-action! and improve register-action!
• Add clj-kondo hook for proxy+.
  

Michiel Borkent

2025 Annual Funding Report 1. Published February 28, 2025.

Sponsors

I’d like to thank all the sponsors and contributors that make this work possible. Without you, the below projects would not be as mature or wouldn’t exist or be maintained at all. Top sponsors:

• Clojurists Together
• Roam Research
• Nextjournal
• Toyokumo
• Cognitect
• Kepler16
• Pitch

If you want to ensure that the projects I work on are sustainably maintained, you can sponsor this work in the following ways. Thank you!

• Github Sponsors
• The Babaska or Clj-kondo OpenCollective
• Ko-fi
• Patreon
• Clojurists Together

If you’re used to sponsoring through some other means which isn’t listed above, please get in touch. Thank you! On to the projects that I’ve been working on!

As I’m writing this I’m still recovering from a flu that has kept me bedridden for a good few days, but I’m starting to feel better now. Here are updates about the projects/libraries I’ve worked on in the last two months.
As I’m writing this I’m still recovering from a flu that has kept me bedridden for a good few days, but I’m starting to feel better now.

Here are updates about the projects/libraries I’ve worked on in the last two months.

• clj-kondo: static analyzer and linter for Clojure code that sparks joy.
  • Unreleased:
  • #2493: reduce image size of native image
  • 2025.02.20:
  • #2473: New linter: :unknown-ns-options will warn on malformed (ns) calls. The linter is {:level :warning} by default. (@Noahtheduke)
  • #2475: add :do-template linter to check args & values counts (@imrekoszo)
  • #2465: fix :discouraged-var linter for fixed arities
  • #2277: prefer an array class symbol over (Class/forName …) in defprotocol and extend-type
  • #2466: fix false positive with tagged literal in macroexpand hook
  • #2463: using :min-clj-kondo-version results in incorrect warning (@imrekoszo)
  • #2464: :min-clj-kondo-version warning/error should have a location in config.edn (@imrekoszo)
  • #2472 hooks api/resolve should return nil for unresolved symbols and locals
  • #2472: add api/env to determine if symbol is local
  • #2482: Upgrade to Oracle GraalVM 23
  • #2483: add api/quote-node and api/quote-node? to hooks API (@camsaul)
  • #2490: restore unofficial support for ignore hints via metadata
• squint: CLJS syntax to JS compiler
  • Fix #609: make remove return a transducer when no collection is provided
  • Fix #611: Implement the set? function (@jonasseglare)
  • Fix #613: Optimize aset
  • Fix #626: Implement take-last
  • Fix #615: (zero? “0”) should return false
  • Fix #617: deftype field name munging problem
  • Fix #618: Named multi-arity fn args don’t get munged (@grayrest)
  • Fix #622: operator precendence issue with | and if
  • Add clojure.string functions lower-case, upper-case, capitalize (@plexus)
  • Fix #605: merge command line –paths with squint.edn config properly
  • Fix #607: make mapcat return a transducer if no collections are provided (@jonasseglare)
• babashka: native, fast starting Clojure interpreter for scripting.
  • Experimenting upgrading to new beta core.async, work in is a branch ready to be merged
  • #1785: Allow subclasses of Throwable to have instance methods invoked (@bobisageek)
  • #1791: interop problem on Jsoup form element
  • #1793: Bump rewrite-clj to 1.1.49 (fixes parsing of foo// among other things)
  • Bump deps.clj
  • Bump fs
• fs - File system utility library for Clojure
  • v0.5.24 (2025-01-09)
  • #135: additional fix for preserving protocol when calling fs/path on multiple arguments (@Sohalt)
• SCI: Configurable Clojure/Script interpreter suitable for scripting
  • Records should have keys present and set to nil
• deps.clj: A faithful port of the clojure CLI bash script to Clojure
  • Catch up with several new versions of clojure CLI
  • Fix #132: copy install tools.edn to config dir when install version is newer, similar to clojure CLI bash script
  • Adds support for XDG_DATA_HOME environment variable according to XDG Base Directory Specification
• sql pods: babashka pods for SQL databases
  • Add support for DuckDB (@avelino)
• edamame: Configurable EDN/Clojure parser with location metadata
  • Fix #115: add location to exception for invalid keyword
• rewrite-edn: Utility lib on top of rewrite-clj with common operations to update EDN while preserving whitespace and comments
  • #40: assoc/update now handles map keys that have no indent at all (@lread)
  • #43: bump rewrite-clj to 1.1.49 (@lread)
  • #40: assoc/update now handles map keys that have no indent at all (@lread)
  • #40: assoc/update now aligns indent to comment if that’s all that is in the map (@lread)
  • #40: update now indents new entries in same way as assoc (@lread)
    

Other projects I’ve been working on this month. See Click for More Details.

Peter Taoussanis

2025 Annual Funding Report 1. Published February 27, 2025.

A big thanks to Clojurists Together, Nubank, and other sponsors of my open source work! I realise that it’s a tough time for a lot of folks and businesses lately, and that sponsorships aren’t always easy 🙏
- Peter Taoussanis

Hi everyone! 👋

I’ve been focused recently on getting Telemere v1 over the finish line. That’s been a lot of ongoing work, in part because I’m trying to establish patterns that can be easily shared between a suite of complementary libs (Telemere, Tufte, and Truss).

I’ve also been considering long-term plans for how to better modularize Encore to help reduce dependency and build sizes where relevant. More on that later in the year.

Truss v2 - an opinionated micro toolkit for Clj/s errors

I’ve recently released Truss v2, which has enlarged the scope of the library from just assertion utils to a general error toolkit for Clojure and ClojureScript.

v2 includes:

• A ground-up rewrite of the existing assertion utils to improve performance, reduce build size, and improve integration with Telemere.
• A new set of small but high-value error utils moved from Encore as part of the ongoing modularization effort.
• A new contextual exception type that’s already used by Encore and Telemere, and will be used by all of my other libraries in future.
• Updated docs and a new Slack channel.
  Truss v2 basically packages together a minimal set of mature tools and patterns that I’ve used over many years to help tame Clojure’s often unruly errors. It’s simple stuff, but practical - and it helps.
  For more info see the README and docstrings.

Telemere v1 RC3 - structured logging and telemetry for Clj/s

I was hoping to release Telemere v1 final this month, but decided that a third release candidate was warranted.

The latest improvements are focused on harmonizing relevant terminology, concepts, and API between Telemere, Truss, and the forthcoming v3 of Tufte.

Big thanks to everyone that’s been helping test and give feedback! v1 final really should (finally) be available next month 🙏

Upcoming work

The next major release planned is Tufte v3. I’ve already got an early draft prepared, but there’s polish needed - and new docs.

v3 improves performance and significantly improves interop with Telemere, offering what I believe to be a pretty compelling combination for Clojure/Script observability and monitoring.

For plans after that, you can see my 2025 roadmap), which as usual I’ll keep updated along the way 👍

Cheers everyone! :-)

Oleksandr Yakushev

2025 Annual Funding Report 1. Published February 28, 2025.

Hello friends! Here’s a short summary of my January-February Clojurists Together 2025 sponsorship work.

CIDER

• I spearheaded the 1.17 and 1.17.1 releases of CIDER.
• The biggest feature of the release is the support for automatic downloading of Java sources (details: https://clojurians.slack.com/archives/C06MAR553/p1739810631203369).
• Auxiliary releases: nrepl 1.3.1, cider-nrepl 0.52.1, Orchard 0.30.1.

clj-async-profiler and Flamebin

• New releases: 1.6.0 and 1.6.1.
• New feature: switchable viewing modes for diffgraphs (details: https://clojurians.slack.com/archives/C06MAR553/p1736447669594659)
• New feature: total percentage is automatically calculated for highlighted frames.
• Both features are also supported at Flamebin (https://flamebin.dev/).

clj-memory-meter

• New release: 0.4.0.
• New feature: memory usage tracing.
• New blog post: I have written about this new clj-memory-meter feature on Clojure Goes Fast blog: Tracking memory usage with clj-memory-meter.trace.

Misc projects

• New release: virgil 0.3.2 - bugfixes.
• New release: clj-java-decompiler 0.3.7 - bugfixes.
  

Permalink

Call for Proposals. Feb. 2025 Member Survey

Greetings folks!

Clojurists Together is pleased to announce that we are opening our Q2 2025 funding round for Clojure Open Source Projects. Applications will be accepted through the 17th of March 2025 (midnight Pacific Time). We are looking forward to reviewing your proposals! More information and the application can be found here.

We will be awarding up to $33,000 USD for a total of 5-7 projects. The $2k funding tier is for experimental projects or smaller proposals, whereas the $9k tier is for those that are more established. Projects generally run 3 months, however, the $9K projects can run between 3 and 12 months as needed. We expect projects to start on April 1, 2025.

A BIG THANKS to all our members for your continued support. We also want to encourage you to reach out to your colleagues and companies to join Clojurists Together so that we can fund EVEN MORE great projects throughout the year.

We surveyed our members again in February to find out what types of initiatives they would like us to focus on for this round of funding. Their responses are summarized below. In particular, it was great to see members' feedback relating to how often they used or referred to developers' work we have funded. Also noted that several of you plan to attend Clojure/Conj, Clojure Berlin MeetUps, SciNoj Light, ClojureX, and ReClojure. CLojurists Together will be one of the sponsors of ReClojure in London this May.

Here is more from our February Members' survey.

What areas of the Clojure and ClojureScript ecosystem need support?

• “Beginners” onboarding. I think we need to make a concerted effort to attract new people (not only people without programming experience) and make the initial stages of “getting into Clojure(Script)” much more guided. Even if that initially means “opinionated”. Once a person has a minimum level of confidence, she can always explore other “opinionated options”. Otherwise, we risk fragmenting the efforts, and making the learners confused (which can led them to rejecting the language).
• We need to gain more hype and visibility in the wider software development community
• Outreach to new developers
• Learning experience for people who are not senior developers. Build tooling and getting started material for newcomers
• Data Science - can I make an R-quality chart without Python?
• Shadow - linting and bus-factor - Shadow is fiendishly complex judging by the rate of questions on Slack, and there is just one expert.
• ClojureDart
• New use cases, data analysis, clojure in academia, beginner resources, interop
• JS Ecosystem interop. How to use stuff like shadcn, tailwind etc. These things should not be so different from how people do it in JS.
• Scientific Clojure and Clojure for data processing
• DX tools.
• Build tooling the introduction of deps has made the ecosystem more difficult to get into
• The developer experience - it is already good, but it could be so much better. Better, more usable error messages, stack traces and better / easier to use profiling tools and tools for structuring builds
• The core is stagnant, especially the spec debacle.

What areas of the Clojure and ClojureScript ecosystem are strong?

• Just a great community
• Clojure-JVM language maintenance
• Web development, data processing
• The language. The tooling is becoming stronger, but more to go I think.
• Developer Experience Tools for experienced devs
• Very excited about all the work around the data science scene ie noj, clerk
• Clojure async, scripting, and web use cases are well covered
• Core language
• Build tooling
• The backwards compatibility and stability of libraries
• Linting
• Core libraries for config, web apps, routing, database interaction are all well served
• In general everything just works and is very stable, can’t wish for a better ecosystem to build on.

Are there any particular libraries, tools, or projects that are important to you that you would like to see supported?

• Jank (3) Jank seems increasingly important to use all the C++ AI related libs and models.
• Malli (3)
• shadow-cljs (3)
• Everything borkdude is doing (3)
• Babashka (2)
• Calva (2)
• CIDER (2)
• ClojureDart (2)
• Clojure LSP (2)
• Datalevin (2)
• Reitit (2)
• SciCloj (2)
• BB, carmine, Cheshire, clang, clay, clj-kondo, Clojars, clojupyter, clojure.jdbc, Cloverage, Conjure, Datahike, datomic-related, dtype-next, Duct (for deps.edn), Elasticsearch (spandex), fastmath, FlowStorm, Fulcro, girouette, http-kit, honeysql, HugSQL, kindly, Neanderthal, next-jdbc, nippy, noj, parinfer, Pathom, Portal, python-clj, Reagent, Shadow, snitch. NBBAero, squint/cherry. tableplot. tech.ml.dataset. A continuation of oz. Statistical libraries (say brms), uix

• I would LOVE to see some additional testing and cleanup work on Bifurcan–I’ve been using it a ton recently and it’s a big step up from the standard Clojure data structures

What would you like to be different in the Clojure community in the next 12 months?

• That AI’s get better at writing/reviewing Clojure code.
• I would love to see wider adoption of cljs on node.
• More cljc portable libraries usable in the JVM, browser, and Dart
• A plan for growth into new use cases, fields, and user personas
• Good integrations of Clojure IDEs with LLMs
• User-friendly developer tools: easy bootstrap, easy frameworks, a starting point to move fast from the start
• Moldable development
• Clojure data science tools with paths to reach parity with R and python
• I would love an online course for free
• Better support and tutorials around datalog databases beyond datomic
• Some kind of consensus as to how to create “quickstart” applications for various usecases that will make the Clojure ecosystem easier for new users to approach and for existing Clojurians to “sell” the stack into the teams that they work with. Ruby had / has Rails, Elixir has Phoenix, Node had / has Express, Python had / has Flask - Clojure needs a toolchain to create the same skeletons without departing from the many libraries approach that makes Clojure eventually far more versatile, down the road.
• Show the broader dev community that choosing Clojure for new projects is viable.
• We need to gain more hype and visibility in the wider software development community.
• More outreach, articles and so on to new developers.
• Improve adoption for non-Clojure users.
• It would be great to think of how we can grow the Clojure community so that it will be sustainable in the long run. What are some ways we can reach new audiences and bring more people into the community?
• I’d like it to be easier for newcomers to Clojure to get started.

Permalink

Clojure Deref (Mar 6, 2025)

Permalink

Clojure vs. Other Functional Programming Languages: A Quick Comparison

Functional programming has gained momentum in recent years, with several languages
leading the charge. Among them, Clojure stands out for its Lisp-based syntax, dynamic
typing, and seamless JVM interoperability. But how does it compare to other popular
functional programming languages like Haskell, Scala, and Elixir? Let’s dive in.

Clojure vs. Haskell

Key Differences

• Haskell enforces strict functional purity with a strong static type system, while Clojure offers more flexibility with dynamic typing.

• Haskell’s laziness can lead to better performance in some cases, whereas Clojure’s JVM integration makes it more practical for real-world applications.

• Clojure is widely used in web applications and data processing, while Haskell finds its niche in academic and high-assurance systems.

Clojure vs. Scala

Key Differences

• Scala combines functional and object-oriented paradigms, making it more familiar to Java developers, while Clojure embraces a minimalist, Lisp-style approach.

• Clojure’s simplicity leads to better code maintainability, but Scala’s type safety helps catch errors at compile time.

• Scala is often preferred in large-scale enterprise applications, while Clojure shines in smaller, agile teams focusing on simplicity and expressiveness.

Clojure vs. Elixir

Key Differences

• Elixir runs on the BEAM VM, making it ideal for building distributed and fault-tolerant systems like messaging apps and real-time applications.

• Clojure’s JVM integration gives it a broader use case across web development, data science, and AI applications.

• Elixir has a more approachable syntax, especially for developers coming from Ruby, while Clojure’s Lisp-like syntax can be more challenging for newcomers.

Final Thoughts

Clojure, Haskell, Scala, and Elixir each bring unique strengths to the table. If you prioritize simplicity and JVM interoperability, Clojure is a solid choice. Haskell is great for pure functional programming enthusiasts, Scala is ideal for enterprise-level applications, and Elixir is the go-to for highly concurrent, distributed systems. The best choice ultimately depends on your project requirements and personal preferences.

The post Clojure vs. Other Functional Programming Languages: A Quick Comparison appeared first on Flexiana.

Permalink

The sources of software complexity

Our last Apropos was with Alex Engelberg. Check it out. Our next episode is with Paula Gearon on March 11. Please watch us live so you can ask questions.

Have you seen Grokking Simplicity, my book for beginners to functional programming? Please check it out or recommend it to a friend. You can also get it from Manning. Use coupon code TSSIMPLICITY for 50% off.

The sources of software complexity

In No Silver Bullet, Fred Brooks defines the line of discussion around software complexity. He identifies two broad classes of difficulty in software: essential and accidental. The essential is irreducible. You cannot get rid of it because it is inherently part of the task of writing software. The accidental is anything that could in principle be eliminated and you still get working software.

He also identified complexity as an essential difficulty in software. Brooks writes: As software grows in size, it “is not merely a repetition of the same elements in larger sizes, it is necessarily an increase in the number of different elements. In most cases, the elements interact with each other in some nonlinear fashion, and the complexity of the whole increases much more than linearly.”

Brooks also defines two similar conjectures which I call the strong and weak conjecture. The strong conjecture is that less than 90% of time is spent on accidental difficulties. Because of this, we will never see an order of magnitude improvement in software development speed.

The weak conjecture is that there won’t be a single improvement (a silver bullet) that alone accounts for an order of magnitude improvement in software development speed within a decade.

It’s always puzzled me why he made the weak conjecture. It’s weaker in two ways. First, there’s the deadline of one decade. If essence is less than 10%, it shouldn’t matter how long you give it. It’s in principle impossible to improve by an order of magnitude. Second, he limits it to a single improvement acting alone. This one allows him to weasel out of arguments about two improvements acting in concert, which he does repeatedly in the follow-up essay, ‘No Silver Bullet’ Refired.

I believe Brooks was wrong in the strong conjecture. He suffered from a lack of imagination about what we could do with the increases in computer power available to us. We turned a lot of what he called essential difficulties into non-problems. Dan Luu has a pretty insightful essay on how techniques like version control and software testing have done wonders for turning the essential into accidental.

As for the weak conjecture, I think it’s arbitrary and worthless. Who cares how you count improvements, and why a decade?

Check out two podcast episodes I did about the essay: 1 and 2.

In Out of the Tar Pit, Ben Mosely and Fred Marks argue that complexity is the major problem in software development. They redefine essential complexity as that due to the domain (instead of that inherent in software development). Accidental complexity is complexity due to something else, such as from bad language design or poor programming practices.

They identify two major sources of complexity: state and control. State leads to complexity because software systems can get into a bad state. And control leads to complexity because of the ordering of execution. They then try to show how using functional programming and the relational model can eliminate most accidental complexity. It’s a very good read that demonstrates a lot of first-principles thinking.

However, the division between essential and accidental is fraught with ambiguity. If you can eliminate it, it’s obviously accidental. But if you don’t know how to eliminate it, you can’t really tell if you haven’t found a way to eliminate it yet, or if it is truly essential. It’s a helpful concept, but not that helpful.

I much prefer to clearly delineate the sources of complexity. Here is an example list of sources of complexity:

• Domain complexity (ex: rocket science is just hard)

• Business complexity (ex: the business wants to bill clients based on usage)

• Architectural/platform complexity (ex: we have to deal with client/server issues on the web)

• Language complexity (ex: we need the visitor pattern in Java)

• Code complexity (ex: we introduced an unnecessary indirection)

If we identify a certain problem in our code as coming from the design of the Java language, we can deal with it in two ways. One, we can avoid it by changing languages. If we can’t do that, then we can isolate it. We build indirection to route around the bad design. We add linters to help us steer clear of the bad design. We increase the testing to make sure we aren’t bitten by the complexity.

It’s not necessary to come up with an exhaustive, indisputable list of sources. Instead, it is important to know that one can identify the source of complexity to the granularity you find useful. We can ask “Why is the browser always getting out of sync with data on the server? Oh, it’s because we’re on the web and that brings with it some complexities.” After identifying it, we can then isolate it. Add to the list if you need more resolution into your problem.

Complexity is real. And it’s a killer. We should be constantly on the lookout for how to avoid it. And when we can’t avoid it, we should isolate it. Having a list of sources of complexity can help you understand it better. I’ve presented the list I use. Next week I want to talk about why poor data modeling is a major source of complexity.

What sources do you typically use to classify complexity?

Permalink

How Multiply went from Datomic to XTDB to Rama

This PState is called $$subs (PState names always begin with $$ ) and is equivalent to a distributed key/value database. Its schema is a map from Sub to AccountId .

Another PState tracks information for every registered email:

Every organization can have an arbitrary number of LLM requests, and each LLM request can receive an arbitrary number of tokens. The inner map-schema tracks all the LLM requests for an organization, and the inner vector-schema is the list of response tokens for that LLM request. This PState uses the :subindex? flag, which tells Rama that value should have its elements indexed individually instead of the whole value being serialized as a whole. This lets those nested data structures be of huge size while still being able to read and write to them quickly.

Permalink

Radar Trends to Watch: March 2025

Anthropic’s announcement of Claude 3.7 Sonnet notwithstanding, the breakneck pace of major AI announcements seemed to slow down through February. That gave us some time to look at some other topics. Two important posts about programming appeared: Salvatore Sanfilippo’s “We Are Destroying Software” and Rob Pike’s slide deck “On Bloat.” They’re unsurprisingly similar. Neither mentions AI; both address the question of why our hardware is getting faster and faster but our applications aren’t. We’ve also noted the return of Pebble, the first smart watch, and an AI-driven table lamp from Apple Research that looks like it came from Pixar’s logo. Fun, perhaps, but don’t look for it in Apple Stores.

Artificial Intelligence

• Anthropic has released Claude 3.7 Sonnet, the company’s first reasoning model. It’s a “hybrid model”; you can tell it whether you want to enable its reasoning capability. You can also control its thinking “budget” by limiting the number of tokens it generates for the reasoning process.
• The Computer Agent Arena is a platform for crowdsourced agent testing. It allows anyone to run an agent using two different AI models, observe what the agent is doing, and rate the results. Results are summarized on a leaderboard; right now, Claude 3.5 Sonnet is at the top.
• Google is developing a “co-scientist” that suggests hypotheses for scientists to investigate. The hypotheses are based on the scientist’s goals, ideas, and past research. The company’s looking for researchers to help with testing.
• GitHub has upgraded agent mode for Copilot. It will now iterate on buggy code until it delivers correct results, and can add new subtasks to the original if they’re needed to accomplish the user’s goal.
• Open-R1 is a new project that intends to create a fully open reproduction of DeepSeek R1. In addition to code and weights, this project will release all tools and synthetic data used to train the model.
• Moshi is a new conversational (speech-to-speech) language model that is constantly listening and can handle interjections like “uh huh” without getting confused.
• Codename Goose is a new open source framework for developing agentic AI applications. It uses Anthropic’s Model Context Protocol for communicating with systems that have data, and can discover new data sources on the fly.
• The University of Surrey will be building a language model for sign language. One focus will be translating between spoken language and sign language. The goal is to ensure that the deaf community isn’t left behind by the explosion of AI tools.
• Galileo is an agentic toolset for detecting when an AI model is hallucinating. It’s particularly important for agentic systems, where an error by one agent leads to misbehavior by others downstream.
• A group of researchers released s1, a 32B reasoning model with near state-of-the-art performance. s1 cost only $6 to train. A very small set of training data (only 1,000 reasoning samples) proved sufficient when the model was forced to take extra time for reasoning.
• Some researchers published How to Scale Your Model, a book on how to scale large language models. The book is apparently internal documentation from Google DeepMind.
• OpenAI has released o3-mini, a small and cost-efficient language model based on its (still unreleased) o3 reasoning model.
• Anthropic has deployed its Constitutional Classifier for adversarial testing by the public. The classifier is a system that protects Claude models from jailbreaks and attempts to get Claude to answer questions that aren’t allowed. Early results look very good.
• The lesson to learn from DeepSeek R1 is that, given a good foundation model, it’s less difficult than many thought to develop a reasoning model. In the coming months, expect many open alternatives.
• OpenAI has introduced DeepResearch, an application based on its o3 model that claims the ability to synthesize large amounts of information and perform multistep research tasks.
• Sam Altman has acknowledged that OpenAI is on the “wrong side of history” as far as open source AI but also said that addressing the issues was not a high priority.
• Alibaba has launched Qwen2.5-Max, another large language model with performance on the same level as GPT-4 and Claude 3.5 Sonnet. It can be accessed through Qwen Chat or Alibaba’s cloud.
• Transformer Lab is a tool for experimenting with, training, fine-tuning, and programming LLM models locally. It’s still installing, but it looks like Ollama on steroids.
• smolGPT is “a minimal PyTorch implementation for training your own small LLM from scratch.”
• Yes, Microsoft is complaining that DeepSeek used OpenAI to generate synthetic training data. Those objections didn’t stop it from making DeepSeek available on Azure.
• Two composers collaborated with Google’s Gemini to create The Twin Paradox, a work for a classical symphony orchestra.
• Alibaba has released two “checkpoints” to its models, Qwen2.5-7B-Instruct-1M and Qwen2.5-14B-Instruct-1M. These models have large 1M-token context windows. Alibaba has also open-sourced its inference framework, which the company claims is three to seven times faster.
• TinyZero reproduces DeepSeek’s R1 Zero, a reasoning model with 3B parameters. Training TinyZero cost under US$30. You could download TinyZero, but you could also make your own for less than the cost of an evening out. Do we need expensive models?

Programming

• Tanagram is promising a toolset for helping developers understand and work with complex codebases. So far, there are only demos, but it sounds interesting.
• Harper Reed describes his workflow for programming with AI. Developing a workflow is essential to using AI effectively, and Harper has given the most thorough description we’ve seen.
• Like Linux, Ruby on Rails can run in the browser. This hack uses WebAssembly.
• Linux booting inside a PDF in Chrome. PDF implementations support JavaScript; C can be compiled into a subset of JavaScript (asm.js), which means that a RISC-V emulator can be compiled to JavaScript and run in a PDF in the browser, which then runs Linux. An amazing hack.
• OCR4all provides free and open source optical character recognition software. Should you need it.
• Why does software run no faster than it did 20 or 30 years ago, despite much faster computers? Rob Pike has some thoughts on controlling bloat.
• As the name implies, Architectural Decision Records (ADRs) capture a decision about software architecture and the reason for the decision. All too frequently, this information isn’t captured. It is likely to become more important in the era of AI-assisted software development.
• Jank is a new general purpose programming language. It’s a dialect of Clojure that incorporates ideas from many other languages, including C++ and Rust, and is built on top of the LLVM.
• Here’s a set of patterns for building real-time features into applications.
• Salvatore “antirez” Sanfilippo’s post, “We Are Destroying Software,” is a must-read. (It says nothing about AI.) It starts “We are destroying software by no longer taking complexity into account.”
• Script is a Go library that makes it possible to do shell-like programming in Go. Its biggest contribution is the ability to create pipes; it also has Go functions that are similar to grep, find, head, tail, and other common shell commands.

Security

• Threat actors aligned with Russia are targeting Signal, the secure messaging application, with phishing attacks that link users’ accounts to hostile devices. One group sends QR codes that look legitimate but link to a device under their control; another impersonates an application used by Ukraine’s military. The best protection is to update to the latest version of Signal.
• Two new vulnerabilities in OpenSSH have been found. One exposes OpenSSH servers to man-in-the-middle attacks; the other can lead to denial-of-service attacks. An update has been released; install it.
• DarkMind is a new attack against reasoning language models. It’s possible to build custom applications (like those in the GPT Store) with “hidden triggers” that modify the reasoning process.
• A new kind of supply chain attack involves obtaining abandoned AWS S3 buckets that still hold libraries that are frequently downloaded. The new owner can insert malware into the libraries; the original owner, who abandoned the bucket, can’t patch the corrupted libraries.
• Security is blocking AI adoption, particularly in heavily regulated industries. That’s understandable; many of the questions we ask of secure systems can’t be adequately answered for AI.
• Microsoft’s AI Red Team has published Lessons from Red Teaming 100 Generative AI Products. It’s essential reading for anyone interested in building a secure AI system.
• AI is being used to submit fake feature requests and bug reports on open source projects. Many of these may be inadvertent, but regardless of cause, it’s generating problems for software maintainers.
• Linux has a number of tools for detecting rootkits and other malware. Chkrootkit and LMD (Linux Malware Detect) are worth your attention.
• Time Bandit is a new jailbreak for the GPT models. The attack causes the model to lose track of past, present, and future. Essentially, you ask GPT how someone in the past would do something that can only be done in the present. It’s unclear whether this attack works on other models.
• When the price of bitcoin goes up, so does the frequency of cryptojacking: hijacking computers to form crypto-mining botnets. It’s claimed that for every dollar of crypto that’s mined, the victim incurs $53 in cloud costs.
• A new backdoor to VPNs has been discovered in the wild, giving attackers access to corporate networks. These backdoors stay dormant until they are triggered by a specially constructed “magic packet,” making them difficult to detect.

Web

• As more people ask AI for product recommendations, marketers will need to optimize product perception by language models. Does LLMO replace SEO? Optimizing for an LLM may be the next generation of SEO.
• This article tells you how to opt out of Gemini features in Gmail and other Google Workspace applications. It’s possible to disable Gemini selectively. Unfortunately, it requires you to have access to the administrator’s console.
• JavaScript’s Temporal object is starting to appear in browsers! Temporal is a replacement for the inadequate Date object. It allows programmers to work effectively with dates and times.
• Marginalia is an open source search engine that prioritizes noncommercial resorts.

Quantum Computing

• Microsoft has created a topological qubit on a new quantum chip. While its chip currently has only 8 qubits, Microsoft claims it can scale to millions of qubits. Putting this many qubits on a chip would go a long way to solving the problem of moving quantum data between chips.
• Canadian startup Xanadu has built a quantum computer using photonics. It currently has 12 qubits, but the company believes it can scale to larger systems.

Robotics

• Robotic models of extinct animals are helping paleontologists discover how those animals might have lived: how they walked, swam, and flew in their environments.

Gadgets

• Pebble returns? Remember the crowdfunded Pebble smartwatch that was available long before Apple’s Watch? It’s coming back—maybe. And it will be hackable.
• Something we all need: An engineering team at Apple developed an AI-driven table lamp. Not available in an Apple Store near you.

Permalink