Link: Lisp’s Influence on Ruby. Once I wrote users.select { |u|… | by Ian Johnson | Jun, 2026 | Medium : blog.tacoda.dev/lisps-influe…

It’s a good thing I’ve had a ponytail since well before I started working with computers - and that was a long time ago - or that guy and I would have something in common. 😂😂😂 github.com/DietrichGebert/po…

Hold your horses, it looks like it's not over yet!

Acho que fui assistir o filme novo do Spielberg, "Dia D" (Disclosure Day), com expectativas muito altas. Para quem curte e conhece o assunto tratado no filme, é um bom entretenimento, nada mais do que isso.

vibeCodedAppSecurity

We've spent far too much time writing code of questionable quality—overly complicated and endlessly justified for one reason or another. Technical debt kept being pushed forward with the classic excuse: "We'll refactor it later." Now AI agents can look at that tangled mess and reorganize it in minutes. And yes, that's genuinely impressive. The productivity gains are enormous. But perhaps there's also a contrast effect at play. If you're starting from chaotic code, a tool that organizes it almost instantly feels like a miracle. On the other hand, if you've always made an effort to write simple, well-structured, and efficient code, the benefits are still there—but the "miracle" doesn't seem nearly as dramatic. What concerns me most isn't that AI makes mistakes. That will improve over time. What concerns me is the shift in incentives: some people already seem less worried about code quality because they assume there will always be an AI agent to fix it later. In my view, AI's greatest potential is not to give us permission to write worse code. It's to help us write even better code by eliminating mechanical work, allowing us to focus more on architecture, design, and the decisions that truly matter. If AI's primary role has become rescuing chaotic projects, then perhaps the miracle isn't AI itself. Perhaps it's simply masking how much we've normalized poor code over the years.

Arch Linux Now Believes Malware Incident Under Control: More Than 1,500 Affected Packages Wow! phoronix.com/news/Arch-Linux…

The US government, citing national security authorities, has issued an export control directive to suspend all access to Fable 5 and Mythos 5 by any foreign national, whether inside or outside the United States, including foreign national Anthropic employees. The net effect of this order is that we must abruptly disable Fable 5 and Mythos 5 for all our customers to ensure compliance. Access to all other Claude models is not affected. We apologize for this disruption to our customers. We believe this is a misunderstanding and are working to restore access as soon as possible. Read our full statement: anthropic.com/news/fable-myt…

DHH: Basecamp 5, Vibe Coding, and the Future of Rails Main point: @rails is not “old tech”. Rails may become even more valuable in the AI era. Why? AI works better with: > conventions > clear structure > stable patterns > mature APIs > less framework churn Rails code from 10–20 years ago still feels familiar today. That means Rails knowledge compounds. You don’t need to relearn the framework every 2 years. thanks @robbyrussell #RubyOnRails #Rails #Ruby #AI #Basecamp @37signals @dhh

‼️ UPDATE: It just doesn't stop: Almost 900 Arch Linux packages infected now. lists.archlinux.org/archives…

400 AUR Packages Compromised with Infostealer and Rootkit Arch users: review the list of affected packages and use this script to check your exposure: aur_check.sh gist.github.com/Kidev/59bf9f… discourse.ifin.network/t/400… Hey @dhh , take a look at this.

There are some things about AI that, to be completely honest, are like trying to discuss politics with someone you like who has a completely opposite opinion to yours. Often, things can get ugly and quite hurtful. So, however painful it may be, it's better to give it time and wait to have more consistency at the very end of the debate. Patience is a virtue, a painful one, but it is.

The work towards RubyLLM 2.0 has begun. This is gonna be a very exciting release.

Aqui tem história! 😉🦖🦕 #git #unix cc: @USE_T_I youtube.com/shorts/CUdKFUzrm…

PostgreSQL 19 Beta 1 adds ON CONFLICT DO SELECT. Insert a row. If it already exists, return it. Atomic get-or-create, finally. 👇 #PostgreSQL #SQL

Mas que beleza. Do nada, a conexão da @GrupoAlgar / @algar_oficial aqui da empresa parou, modem com led de alarme vermelho e após contato telefônico fui informado que para alguém vir aqui ver é somente amanhã à tarde! Aqui é uma empresa pô, precisamos trabalhar!

RubyLLM 1.16 is out. - Concurrent Tool Execution - Rails-style Instrumentation - Custom Base URLs for Every Native Provider - Configurable Faraday Adapter - Deprecation Controls - Transcription Words and a deluge of fixes. github.com/crmne/ruby_llm/re…

I've been seeing a lot of posts lately that make me feel like we're bringing back the old, misguided metric of measuring productivity by the number of lines of code generated. It took us decades to move away from that shortsighted obsession with quantity and toward quality, yet the AI marketing machine is running at full speed, selling this idea once again to product owners and project/team managers who perhaps weren't around to witness the disaster this mindset creates in the medium and long term. There are plenty of CEOs out there turning this into a competition over who generates the most lines of code, which is honestly a rather bizarre metric. It's easily "gamifiable," and for that very reason, it fails as a meaningful goal. In the past, people exaggerated this kind of productivity the slow way (and some even bragged about it!). Now AI can do exactly the same thing in record time. To be clear, I'm not against AI. I use it regularly in ways that genuinely improve both my productivity and my knowledge. But, as always, regardless of where the code comes from, it still deserves critical analysis. How many of those lines actually add value instead of merely putting out fires? How many of those thousands of lines end up being discarded after a more thoughtful review? Edsger Dijkstra argued that measuring programmers' productivity by lines of code (LoC) is an extremely costly metric because it encourages the writing of insipid code—monotonous, lacking originality, and devoid of elegance or substance. He believed that lines of code should not be viewed as something "produced," but rather as something "spent," emphasizing that code is a liability: it requires maintenance, increases technical debt, promotes unnecessary complexity, and often leads to poor design, as developers may prioritize quantity over quality. As always, we have a target: to deliver the functionality necessary for the software to remain viable, fulfill its purpose, achieve its objectives, and generate value for both those who build it and those who use it. If those thousands of lines help achieve that while adding even more value—not just reaching today's goal but also making it easier to continue achieving future goals—then that's perfectly fine. But if we start falling back into the old mindset of saying, "We're productive because we delivered the feature," even though we wrote ten or a hundred times more code than necessary, then for software that isn't short-lived—software that will be used, refactored, and evolved over the medium and long term (and perhaps even short-lived software, given how fast things move today)—we'll once again be shooting ourselves in the foot. I've seen this happen many times before: the situation becomes so unsustainable that nobody can effectively maintain the code anymore, and the whole project eventually falls apart. The true measure of efficiency isn't just what happens while the code is being written. I'd even argue that its greatest value is determined after it's been written. "But today's landscape is different from what it was all those years ago." Is it, really? The foundation is essentially the same. The tools have changed. But that's for each of us to decide.

Thoughts after a bike ride. 🚵🏼 Today my daily work is already like this, but I hope more job opportunities will open up for people to use this stack. 😉 #ruby #rails

Resolvi fazer uma pesquisa sobre softwares VCS/SCM e o resultado foi 50 anos de história e 90 minutos de vídeo! 😮 Mas não se preocupem: dá para assistir por capítulos separados, deixei todas as marcações. Mas recomendo fortemente assistir o começo, com o SCCS, para ter uma visão de como tudo começou. 🙂 #vcs #scm #sccs #cvs #subversion #git youtu.be/SMiPYFRHd94