Permalink: 20250117142212

Found at “All-Purpose Machines” on 2025-01-17 14:22:12 +01:00.

HyperMap is a new format for REST APIs that lets you execute JavaScript and WebAssembly on the client

Permalink: 20250115114617

REST allows client functionality to be extended by downloading and executing code in the form of applets or scripts. This simplifies clients by reducing the number of features required to be pre-implemented.—Roy Thomas Fielding and Richard N. Taylor. 2000. Architectural styles and the design of network-based software architectures. Ph.D. Dissertation. University of California, Irvine.

Code-On-Demand REST constraint. The Code-On-Demand constraint described by Roy Fielding in his ‘Architectural Styles and the Design of Network-based Software Architectures’ dissertation is interesting and something you don’t see applied in the wild.

Permalink: 20250115092836

Found at “Introducing CoreAI – Platform and Tools - The Official Microsoft Blog” on 2025-01-15 09:28:36 +01:00.

This is leading to a new AI-first app stack — one with new UI/UX patterns, runtimes to build with agents, orchestrate multiple agents, and a reimagined management and observability layer.

Permalink: 20250114153916

Found at “The problem with design tokens | André Torgal” on 2025-01-14 15:39:16 +01:00.

The modern design system uses tokens to distribute centrally managed design decisions and it faciliates iterating on brand and visual language. In most of the cases it support light/dark mode context but some are also dealing with multiple brands and identities at the same time. With some effort and crafty engineering, many are building token pipelines with integrations, transformations, and automatic docs generation.

Permalink: 20250110163031

Found at “The magic of the commons | Seth’s Blog” on 2025-01-10 16:30:31 +01:00.

It’s not that difficult to try to selfishly take advantage of the generous rules of open source. It’s tempting to take without contributing. Particularly if investors are pushing for market share instead of resilience and forward motion.

Permalink: 20250110105812

Found at “Writing as Transformation” on 2025-01-10 10:58:12 +01:00.

the written word can be remembered only exactly; if a written line is not repeated exactly, word for word, it is not being remembered, it is being paraphrased

Permalink: 20250110105403

Found at “The Seven-Action Documentation model - passo.uno” on 2025-01-10 10:54:03 +01:00.

docs frameworks and tools are essential ingredients to holding a sandwich together and handle it, but what gives a sandwich all the taste and meaning is the filling, that is, the mental model of user needs that you’re following

Permalink: 20250108214714

Found at “tilpython2025-01-07-scripting-GMail.md at main · pdubroytil · GitHub” on 2025-01-08 21:47:14 +01:00.

Please give me a python script that uses the GMail API. Given a query string, it should search for all messages that match the query string, and then download the attachments from those messages to the current working dir. Make it a standalone script that uses the uv tool, with inline dependencies if necessary.

Permalink: 20250108144907

Computers really didn’t start making an impact in the Design community until the late 80s. At the time, a lot of the OG designers of that era were vehemently opposed to using the computer. They were certain that we were going to lose jobs. It was going to take all the creativity out of the process, out of the way in which we created. It was going to create soulless work.—Debbie Millman, during the New York chapter of CreativeMornings on Dec 5, 2024, in conversation with Seth Godin

Permalink: 20250108121231

Found at “Calculating Empires” on 2025-01-08 12:12:31 +01:00.

Calculating Empires is a large-scale research visualization exploring how technical and social structures co-evolved over five centuries.

Permalink: 20241231000608

Found at “LN 040: The venerable hyperlink” on 2024-12-31 00:06:08 +00:00.

Alan Kay has talked about how the personal computer should work like the Internet: lots of late-bound programs passing around messages.

Permalink: 20241226230102

Found at “AI-generated tools can make programming more fun” on 2024-12-26 23:01:02 +00:00.

This is the dream of malleable software: editing software at the speed of thought. Starting with just the minimal thing we need for our particular use case, adding things immediately as we come across new requirements. Ending up with a tool that’s molded to our needs like a leather shoe, not some complicated generic thing designed for a million users.

Permalink: 20241219141406

Found at “Developing Developers” on 2024-12-19 14:14:06 +01:00.

Teaching explicit and systematic design introduces students to a general problem-solving approach that applies to many more domains than programming.

Permalink: 20241219095650

Exciting!

Found at “shaprmarkovkeyboard: keyboard layout that changes by markov frequency” on 2024-12-19 09:56:50 +01:00.

Static keyboard layouts are boring and predictable. Let’s spice up the whole idea of keyboard layouts by having the layout CHANGE WHILE YOU ARE TYPING!

Permalink: 20241218180654

(…) give a child an environment that’s active like him. It’s an environment in which thinking and creativity are the natural kinds of things that are done.—Alan Kay

Permalink: 20241218152102

Found at “Ethical Web Principles” on 2024-12-18 15:21:02 +01:00.

The web should be a platform that helps people and provides a positive social benefit

Permalink: 20241218151843

Found at “Never Forgive Them” on 2024-12-18 15:18:43 +01:00.

I don’t believe that this gradual enshittification is part of some grand, Machiavellian long game by the tech companies, but rather the product of multiple consecutive decisions made in response to short-term financial needs.

Permalink: 20241218151351

Found at “Tools for Thought as Cultural Practices, not Computational Objects” on 2024-12-18 15:13:51 +01:00.

If only to make clear to ourselves why we currently consider apps that allow you to link notes together the epitome of a tool for thought.

Permalink: 20241217115255

Protobuf has a new Opaque API.

Found at “Go Protobuf: The new Opaque API - The Go Programming Language” on 2024-12-17 11:52:55 +01:00.

With the Opaque API, the struct fields are hidden and can no longer be directly accessed. Instead, the new accessor methods allow for getting, setting, or clearing a field.

Permalink: 20241213153714

Trying an API is a natural extension to documentation.

While documentation—and reference, in particular—provides a source of truth of what the API is capable of, trying offers a layer of experimentation. Trying isn’t about understanding the capabilities of the API; it’s about seeing how they work.

Permalink: 20241205010513

Found at “Using Bluesky posts as blog comments” on 2024-12-05 01:05:13 +01:00.

Your blog’s comment section can be pulled directly from Bluesky.

Permalink: 20241204234157

Found at “Genie 2: A large-scale foundation world model - Google DeepMind” on 2024-12-04 23:41:57 +01:00.

Genie 2, a foundation world model capable of generating an endless variety of action-controllable, playable 3D environments for training and evaluating embodied agents.

Permalink: 20241130111417

Found at “The Influence of Bell Labs - by Brian Potter” on 2024-11-30 11:14:17 +01:00.

following WWII, research spending by both the government and the private sector increased enormously

There’s a well-known phenomenon that technological progress is often driven by bubbles, as irrational enthusiasm drives huge amounts of investment in a novel technology far beyond what can be economically justified.

Permalink: 20241127094934

Inverting the flow of control is something I was hoping to see for a while. The concept of human-in-the-loop (HITL) isn’t something new. However, seeing it all put together so nicely is interesting.

Found at “HumanLayer” on 2024-11-27 09:49:34 +01:00.

HumanLayer is an API and SDK that enables AI Agents to contact humans for feedback, input, and approvals.

Permalink: 20241126140636

Found at “Introduction to Causal Logs | Joel Gustafson” on 2024-11-26 14:06:36 +01:00.

People use apps, apps use databases, and databases use logs. Logs are useful because they make distributed replication easy, and can be deterministically reduced, but they’re inherently single-writer. All appends must go through a single point.

Permalink: 20241126122813

Found at “Deactivating an API, one step at a time” on 2024-11-26 12:28:13 +01:00.

The only suggestion I’d add is to implement API brownouts - short periods of time where the deprecated API returns errors, several months before the final deprecation. This can help give users who don’t read emails from you notice that they need to pay attention before their integration breaks entirely.

Permalink: 20241125204333

Found at “Introducing the Model Context Protocol \ Anthropic” on 2024-11-25 20:43:33 +01:00.

The Model Context Protocol provides a universal, open standard for connecting AI systems with data sources, replacing fragmented integrations with a single protocol.

Permalink: 20241122165821

Knowing how it works isn’t what makes it work. The magic of it isn’t how it works. The magic is the magic.—Rick Rubin

Permalink: Thoughts on OpenAPI JSON Schema descriptions

I recently posted that I wish the OpenAPI JSON Schema still had descriptions like it used to on v2.0. My post triggered a discussion on the official OpenAPI Slack, explaining they had removed the descriptions to avoid maintenance costs related to keeping the descriptions in sync in several places. I joined the discussion on Slack to share my perspective. The following is a transcript of what I wrote for future reference.

I’m looking at https://github.com/OAI/OpenAPI-Specification/blob/main/schemas/v3.1/schema.yaml and using it as the JSON Schema I refer to in the following comments.

• Using $comment is great. However, according to the spec, “JSON schema implementations aren’t allowed to attach any meaning or behavior to it whatsoever.” Comments are useful for leaving notes to other editors that aren’t meant to be passed to the end user. (see https://json-schema.org/understanding-json-schema/reference/comments)
• Most $comments are being used to reference the corresponding section of the OpenAPI spec. While that’s interesting, the links to the reference are all broken (404). As an example, the $comment on paths has the value of https://spec.openapis.org/oas/v3.1#paths-object. Instead, It looks like the correct value should be https://spec.openapis.org/oas/v3.1.0.html#paths-object.
• The description on the exact section of the spec is great for human consumption. On the other hand, extracting the information in a programmatic way is not easy.

My suggestions:

• Using the JSON Schema description annotation to describe what each OpenAPI schema object is.
• Because I see that maintenance cost is the reason why descriptions were removed, why not use the JSON Schema as the source of truth? Then, the sections of the spec could be programmatically generated from the information on the schema, avoiding maintaining two separate documents.

I might, obviously, be missing many other details. However, I wanted to share my opinion in case anyone finds it interesting.

Permalink: 20241119151234

Found at “Causal Islands Berlin 2024” on 2024-11-19 15:12:34 +01:00.

Causal Islands is a conference about the future of computing and a home for new perspectives ranging from deeply technical insights to sharp socio-political analysis.

Permalink: 20241119124718

How do AI agents identify themselves when consuming APIs? Agents are acting on behalf of people, so can they potentially use OAuth 2? Or something else? What about AI agents that act on behalf of other agents? Do we need a different authorization framework?

Permalink: 20241114103310

Found at “No-code, no thought? Substrates for simple programming for all - Tomas Petricek” on 2024-11-14 10:33:10 +01:00.

The idea of programming substrates is generalizing the usual distinction between programming a software system and using a software system.

Permalink: 20241114102943

Found at “Codestrates v2 | Codestrates v2” on 2024-11-14 10:29:43 +01:00.

With Codestrates, you can create dynamic webpages (or webstrates as we call them) that can be edited directly from within the browser — and editing can also be done collaboratively.

Permalink: 20241112122907

The secret to the most creative people I know is they work within a framework and that’s what allows creativity to flow.

Permalink: 20241109165306

What is API Quality?. I published this post on LinkedIn on October 2024. I wanted to understand how people familiar with APIs would define quality. The answers varied significantly but mostly revolved around the notion of technical quality.

Here’s a summary of the answers I captured from my LinkedIn post where I asked “What is API Quality?”

One kind of answer points toward a maturity model, hinting that quality is a technical aspect. The idea is to have a multi-dimensional model that includes what the Richardson and Amundsen (PDF) models offer, adding other layers.

Another view gives importance to the functional interface. There’s no quality if the API doesn’t offer what consumers need. Or, in short, quality is tied to usability. To achieve that, there are aspects such as consistency of interface, and semantic clarity, that should be taken into account. I still see this type of quality as technical.

Some answers connect quality to governance and point out that it’s often not easy to convince people the two are tied. Things like linting, having rules that enforce consistency and naming, and making sure APIs use the right architecture and types of operations are part of this line of thought.

Permalink: 20241107223940

Alan Kay refers to the “Creative Magic” as “Good Woowoo.” (20240306160214)

Permalink: 20241107162227

According to Seth Godin, there are three kinds of quality:

1. Technical.
2. Luxury.
3. Creative magic.

Having technical quality means things work according to specs. Luxury means there’s something about the product that makes it special to consumers. This is often what most people understand as quality. The third kind of quality is the most interesting one. Creative magic is the less-understood attribute that makes people love your product to the point they feel special when using it. Creative magic is what makes consumers recommend your product.

—from The Practice, pp. 75–77

Permalink: 20241106175323

An abstraction provides a higher-level vocabulary that shields the user from the underlying complexity.—Gregor Hohpe

Permalink: 20241101230335

Found at “The Dual Nature of Events in Event-Driven Architecture” on 2024-11-01 23:03:35 +00:00.

events that travel between services have a dual role: They trigger actions and carry data.

Permalink: 20241030144316

Found at “Engraft” on 2024-10-30 14:43:16 +01:00.

Engraft is an API that makes live & rich programming interfaces powerful and practical through composition.

Permalink: 20241029153437

What’s important is expressing your program as what you want it to do. Not a set of instructions on how to do it. Letting the computer itself figure out how to do it.—Bret Victor

Permalink: 20241026183145

Most OpenAPI editors aren’t doing what I think they should. They focus on two things: linting the OpenAPI document and rendering an API reference preview. The second thing puts the focus on creating good-looking API references. API creators will, naturally, try to write their OpenAPI documents so that the API reference looks nice.

When you’re creating, you want to see a preview of what you create. When you write code, you want to see the output of the code running. When you write a markdown document, you want to see it rendered—either in place or on a new panel. When you write an OpenAPI document, you want to see the API it defines running. What you want is to feel the result of what you’re creating.

Permalink: 20241023101956

Found at “The Strategy Questions | Seth’s Blog” on 2024-10-23 10:19:56 +02:00.

Where are the non-believers, and how do I avoid them?

Permalink: 20241010161954

Found at “Tenno” on 2024-10-10 16:19:54 +02:00.

You can think of Tenno as a mix of Word and Excel with a touch of Obsidian, Markdown and Javascript.

Permalink: 20241009160929

Found at “Potluck: Dynamic documents as personal software” on 2024-10-09 16:09:29 +02:00.

it’s critical that the system can provide immediate feedback as a user types and help them develop consistent expectations for how the system will interpret their text.

Permalink: 20241008222032

I’ve been using the first prototype of my API Assistant for a couple of weeks, and it feels like magic. The prototype automatically creates an API server based on the content of an OpenAPI document. I don’t need to write any code or generate any “server stubs” to have my API running. It just updates itself every time I change the OpenAPI document.

Permalink: 20241006153042

Found at “Prototyping APIs with OpenAPI - by Bruno Pedro” on 2024-10-06 15:30:42 +02:00.

I built a personal system for interpreting OpenAPI documents and using them as the only thing needed to run an API

Permalink: 20240929180145

Found at “Alan Kay On Messaging” on 2024-09-29 18:01:45 +02:00.

The key in making great and growable systems is much more to design how its modules communicate rather than what their internal properties and behaviors should be.—Alan Kay

Permalink: 20240927112717

Found at “[1802.07068] Talent vs Luck: the role of randomness in success and failure” on 2024-09-27 11:27:17 +02:00.

if it is true that some degree of talent is necessary to be successful in life, almost never the most talented people reach the highest peaks of success, being overtaken by mediocre but sensibly luckier individuals

Permalink: 20240923221223

Found at “The Intelligence Age” on 2024-09-23 22:12:23 +02:00.

(…) humanity discovered an algorithm that could really, truly learn any distribution of data. To a shocking degree of precision, the more compute and data available, the better it gets at helping people solve hard problems.—Sam Altman

Permalink: 20240919163401

Found at “Paper Programs” on 2024-09-19 16:34:01 +02:00.

I liked how you could physically hold a program in your hands, and then put on any surface in the building, where it would start executing, as if by magic.

Permalink: 20240918153643

Found at “howard rheingold’s | tools for thought” on 2024-09-18 15:36:43 +02:00.

A few of the pioneers of personal computing who still work in the computer industry can remember the birth and the dream

Permalink: 20240912192817

Found at “Learning to Reason with LLMs | OpenAI” on 2024-09-12 19:28:17 +02:00.

We are introducing OpenAI o1, a new large language model trained with reinforcement learning to perform complex reasoning.

Permalink: 20240912141406

Found at “Tidy data” on 2024-09-12 14:14:06 +02:00.

Tidy datasets are easy to manipulate, model and visualize, and have a specific structure: each variable is a column, each observation is a row, and each type of observational unit is a table.

Permalink: 20240911114014

A new omniauth-saml RubyGem version has been released. It mostly fixes security issues related to SAML signatures.

Permalink: 20240910095600

Found at “Why GitHub Actually Won” on 2024-09-10 09:56:00 +02:00.

We cared about the developer experience and had the creativity to throw away assumptions about what it was supposed to be and build how we wanted to work. Everyone else tried to build what they thought they could sell to advertisers or CTOs.

Permalink: 20240908154603

Extensive use of glass in architecture. (…) the extensive use of glass makes the walls appear to be so light that they seem to negate the conventional laws of tectonics.—Sigel, Gilbert Lupfer & Paul. Gropius. Germany: TASCHEN, 2017.

Permalink: 20240908145842

Found at “API Complexity Is a Lie - by Bruno Pedro” on 2024-09-08 14:58:42 +02:00.

Anyone telling you that working with APIs is hard isn’t telling the truth. What is hard isn’t the API. It’s all the tools, processes, and technical language surrounding it.

Permalink: 20240908142926

(…) design should not dominate things, it should not dominate people. It should help people.—Dieter Rams

Permalink: 20240904141932

Found at “11 · Universal comments” on 2024-09-04 14:19:32 +02:00.

When building this system, we aimed to find a minimal API that expresses only the app-specific parts of commenting.