Adam & Jerod discuss the news! But first, we discuss how you can keep up with the software world (good question, Tyler Boyd!) On the docket: Developer job postings trend, the Ladybird Browser Initiative, the Polyfill.js supply chain attack & is the future self-hosted?

Matched from the episode's transcript 👇

We’re joined by Kevin Owocki, the founder of Gitcoin. Gitcoin is a platform to monetize or incentivize work in open source software. We talked about how Gitcoin sits at the intersection of sustaining open source and cryptocurrencies, their history and roadmap, their decision to leverage the brand name of Git, bug bounties, funded issues, web3, MetaMask, and the future of Gitcoin and how open source benefits.

Matched from the episode's transcript 👇

Modifications to Google Chromium for removing Google integration and enhancing privacy, control, and transparency

For those of us who love Chrome too much to leave it, but would prefer not have Google all up in our browser. By the way, now is a pretty good time to give Brave and/or Firefox a spin, if you haven’t recently.

Special thanks to Paul Irish for the hat tip and sharing this tweet:

Sublime Web Inspector: massive JS integration between Sublime & Chrome DevTools sokolovstas.github.com/SublimeWebInsp… (skip to 3:25) Whoa /via @addyosmani

— Paul Irish (@paul_irish) March 17, 2013

For those who haven't yet gone the way of text mode with Vim, you likely hack with Sublime Text (especially if you've given up on TextMate like the rest of us).

Stanislav just released some pretty massive JavaScript integration between Sublime Text and Chrome DevTools with Sublime Web Inspector that lets you debug JavaScript inside the Sublime Text editor.

Follow Paul’s suggestion to watch the video and also check out the readme on GitHub for installation details.

Vote this up on Hacker News.

We’ve covered continuous integration projects such as
Jenkins and Travis
before. Now Goldberg, which has just turned 1.0, jumps into the ring with a CruiseControl.rb-compatible
offering.

Kenneth and Wynn caught up with Kohsuke Kawaguchi and Andrew Bayer from the Jenkins project to talk about continuous integration, Java, and corporate backing drama.

Install this and leave your co-workers asking, “where does s/he get those wonderful toys?”

You may recall Josh gushing about tslime on Episode 0.7.3. While tslime makes it easy to send input from Vim to a tmux session, Ben Mills wanted a bit more, so he created Vimux. Vimux gives you a tmux pane in which to execute commands, all without losing focus in vim.

Commands can easily be set up in your .vimrc to do common tasks:

" Prompt for a command to run
map rp :PromptVimTmuxCommand

" Run last command executed by RunVimTmuxCommand
map rl :RunLastVimTmuxCommand

" Inspect runner pane
map ri :InspectVimTmuxRunner

" Close all other tmux panes in current window
map rx :CloseVimTmuxPanes

" Interrupt any command running in the runner pane
map rs :InterruptVimTmuxRunner

Check out Ben’s introductory blog post for background and how they’re using Vim and tmux at Braintree (which I highly recommend for payment processing by the way).

This week on The Changelog we’re talking with Joe Reis about data engineering and the beginning of generative AI. We discuss phone hacking via frequency, the role of a data engineer, this AI hype cycle we’re in, build vs buy, the disconnect between data analysts and the business, ethical considerations around AI-generated content, and more. We also discuss the tension between AI and traditional engineering, as well as the inevitability of AI integration into pretty much everything.

The hubbub of the web dev world right now is Next.js’ integration of React Server Components, Kent C. Dodds writes up why he doesn’t use Next, Lee Robinson responds with why he does, the NixOS team hits a milestone in their reproducible builds effort & OpenSign is an open source alternative to DocuSign.

Dominik Klotz from askui joins Daniel and Chris to discuss the automation of UI, and how AI empowers them to automate any use case on any operating system. Along the way, the trio explore various approaches and the integration of generative AI, large language models, and computer vision.

Large Language Models (LLMs) continue to amaze us with their capabilities. However, the utilization of LLMs in production AI applications requires the integration of private data. Join us as we have a captivating conversation with Jerry Liu from LlamaIndex, where he provides valuable insights into the process of data ingestion, indexing, and query specifically tailored for LLM applications. Delving into the topic, we uncover different query patterns and venture beyond the realm of vector databases.

We are seeing an explosion of AI apps that are (at their core) a thin UI on top of calls to OpenAI generative models. What risks are associated with this sort of approach to AI integration, and is explainability and accountability something that can be achieved in chat-based assistants?

Beth Rudden of Bast.ai has been thinking about this topic for some time and has developed an ontological approach to creating conversational AI. We hear more about that approach and related work in this episode.

With the recent proliferation of generative AI models (from OpenAI, co:here, Anthropic, etc.), practitioners are racing to come up with best practices around prompting, grounding, and control of outputs.

Chris and Daniel take a deep dive into the kinds of behavior we are seeing with this latest wave of models (both good and bad) and what leads to that behavior. They also dig into some prompting and integration tips.

Nishant Roy, Engineering Manager at Pinterest Ads, joins Johnny & Jon to detail how they’ve managed to continue shipping quality software from startup through hypergrowth all the way to IPO. Prepare to learn a lot about Pinterest’s integration and deployment pipeline, observability stack, Go-based services and more.

Why another file manager? I wanted something simple and minimalistic. Something to help me with faster navigation in the filesystem; a cd and ls replacement. So I build “llama”. It allows for quick navigation with fuzzy searching. cd integration is quite simple. And you can open vim right from the llama. That’s it. As simple and dumb as a llama.

This course from the folks at web.dev targets beginners and advanced developers alike.

You’ll learn PWA fundamentals like the Web App Manifest, service workers, how to design with an app in mind, what’s different from a classic web app, how to use other tools to test and debug your PWA. After these fundamentals, you’ll learn about integration with the platform and operating system, how to enhance your PWA’s installation and usage experience, and how to offer an offline experience.

Carlos Becker shares some SSH tips he’s learned over the years, including YubiKey integration. Did you know you can SSH straight into tmux?!

Baldur Bjarnson:

You don’t need to look far on web dev social media to find somebody lecturing everybody and nobody about how you should do web development. Hell, I’ve been guilty of that myself.

You should use this or that framework.

Or, you should not use this or that framework and instead use a cognitive framework like Model-View-Controller with ‘vanilla’ web components.

No, no, no Functional Reactive is where it’s at.

You should be writing code test-first and unit test everything.

Or, you should go light on the unit tests and focus instead on integration tests.

Or, end-to-end tests. Just test the shit out of the actual running app.

Or, you should use this different kind of unit test which doesn’t look anything like that other kind of unit test.

Those aren’t integration tests! This is an integration test! What’s wrong with you?!
You don’t pair program? Wow, your code must suck.

Sound familiar? Unfortunately, you don’t get to be a “famous” social media influencer by posting reasoned, nuanced takes that end with something like: “I dunno, this works for me but it may not for you. It depends…”

Sid and the GitLab team continue to enjoy their Rails-based “modular monolith”

A modular monolith is the exact opposite of a distributed ball of mud: a well-structured, well-architected, highly modular program that runs as a single process and is as boring as possible.

Sid doesn’t pull any punches. No regrets!

Wouldn’t it be better to have a proper plugin interface? Or better yet, a services interface modeled on microservices? In a word: no. Not only do these approaches impose deployment and integration hurdles that go far beyond “I made a small change to the source code,” they often enforce architectural constraints too rigidly. Anticipating all the future extension points is a fool’s errand, one that we luckily did not embark on and do not have to.

Lexical is an extensible JavaScript web text-editor framework with an emphasis on reliability, accessibility and performance. Lexical aims to provide a best-in-class developer experience, so you can easily prototype and build features with confidence. Combined with a highly extensible architecture, Lexical allows developers to create unique text editing experiences that scale in size and functionality.

It has solid React integration because Facebook, but Lexical has no dependencies and can be used and extended independent of any library or framework.

From Jon Maddox on The GitHub blog (from waaay back in the day):

At GitHub, we have normalized on a set of script names for all of our projects that individual contributors will be familiar with the second after they clone a project. We call them “Scripts to Rule Them All”.

Here’s a mapping of what these scripts are named and their responsibility:

• script/bootstrap – installs/updates all dependencies
• script/setup – sets up a project to be used for the first time
• script/update – updates a project to run at its current version
• script/server – starts app
• script/test – runs tests
• script/cibuild – invoked by continuous integration servers to run tests
• script/console – opens a console

Each of these scripts are responsible for a unit of work. This makes them composable, easy to call from other scripts, and easy to understand.

Note: this was written basically forever ago, but it’s still a relevant and effective solution.

Ships with a file explorer, autocompletion, git integration, status line, fuzzy finding, and more.

If you’re using GitHub as your version control system of choice then GitHub Apps can be incredibly useful for many tasks including building CI/CD, managing repositories, querying statistical data and much more. In this article we will walk through the process of building such an app in Go including setting up the GitHub integration, authenticating with GitHub, listening to webhooks, querying GitHub API and more.

This is our third Kaizen episode in which Adam, Jerod & Gerhard talk about GitOps the wrong way, ask questions with Honeycomb and realise that they must be holding the CDN wrong, and the effort that has been going into moving all changelog.com static files from regular volumes to an S3-like object store. If you like a good yak shake, listening to this one is a lot more fun than doing it.

Gerhard is most excited about the Ship It Christmas gifts that we have been preparing for you. While GitHub Codespaces is not going to be part of the upcoming Christmas special episode, today’s talk covers why investing in a Codespaces integration is worth it.
Changelog #459 and Backstage #20 are related to this topic.

There are a lot of HTTP client tools out there. This one is neat because of its simple/repeatable plain text API that I’d imagine works great for writing integration tests.

# Get home:
GET https://example.net

HTTP/1.1 200
[Captures]
csrf_token: xpath "string(//meta[@name='_csrf_token']/@content)"

# Do login!
POST https://example.net/login?user=toto&password=1234
X-CSRF-TOKEN: {{csrf_token}}

HTTP/1.1 302

Brave Search has some similarities to DDG (which has been my default for a couple years now), but it’s different in that it builds its own index vs relying on Bing and Yandex. Brave’s principles:

1. Privacy: no tracking or profiling of users.
2. User-first: the user comes first, not the advertising and data industries.
3. Independence: Brave has its own search index for answering common queries privately without reliance on other providers.
4. Choice: soon, options for ad-free paid search and ad-supported search.
5. Transparency: no secret methods or algorithms to bias results, and soon, community-curated open ranking models to ensure diversity and prevent algorithmic biases and outright censorship.
6. Seamlessness: best-in-class integration between the browser and search without compromising privacy, from personalization to instant results as the user types.
7. Openness: Brave Search will soon be available to power other search engines.

If those resonate with you, it’s worth a try. Not a Brave Browser user? You can still use search.brave.com.

DenoDB has a fully-typed API (which is great for editor integration) and supports a whole host of backends: MySQL/Maria, SQLite, Postgres, and MongoDB.

Broad database support is great for library adoption, but as a user I’d prefer something that leans in to a specific ecosystem, which usually lets you squeeze more out of it.

Regardless of that, it’s great to see the Deno community building foundational tools like this.

WSLg provides an integrated experience for developers, scientists or enthusiasts that prefer or need to run Windows on their PC but also need the ability to run tools or applications which works best, or exclusively, in a Linux environment. While users can accomplish this today using a multiple system setup, with individual PC dedicated to Windows and Linux, virtual machine hosting either Windows or Linux, or an XServer running on Windows and projected into WSL, WSLg provides a more integrated, user friendly and productive alternative.

WSLg strives to make Linux GUI applications feel native and natural to use on Windows. From integration into the Start Menu for launch to appearing in the task bar, alt-tab experience to enabling cut/paste across Windows and Linux applications, WSLg enables a seamless desktop experience and workflow leveraging Windows and Linux applications.

Microsoft’s engineers just keep crankin’ out the hits.

Continuous integration and continuous delivery are both terms we have heard, but what do they really mean? What does CI/CD look like when done well? What are some pitfalls we might want to avoid? In this episode Jérôme and Marko, authors of the book “CI/CD with Docker and Kubernetes” join us to share their thoughts.