Code

It’s hard to even articulate this scenario with words and pictures. Sometimes you just have to feel it, use it, to understand the nuances.

This all might seem obvious — but the obvious is not always implemented. Sometimes it’s not as obvious as you might think. And sometimes the obvious is just too much work, so it gets skipped.

The point is: look and feel is hard to design, let alone spec, in a design tool. You need someone who understands what’s possible in the medium (and I mean the medium you’ll deliver the interaction in, not the medium you’ll design it in — those can be different).

You need someone who can do design work with code.

...You need either:

1. a person who understands and can work in both forms, or
2. two people who can work closely together to nail down all these details and make decisions along the way until you have something that feels right, that feels intentional, that feels designed all the way through — not “designed” then “implemented”.

If present trends continue, there is the real chance that articles warning about page bloat could exceed 5 megabytes in size by 2020.

The problem with picking any particular size as a threshold is that it encourages us to define deviancy down. Today’s egregiously bloated site becomes tomorrow’s typical page, and next year’s elegantly slim design.

I would like to anchor the discussion in something more timeless.

To repeat a suggestion I made on Twitter, I contend that text-based websites should not exceed in size the major works of Russian literature.

Software's girth has surpassed its functionality, largely because hardware advances make this possible. The way to streamline software lies in disciplined methodologies and a return to the essentials.

Immersive data visualization experiments powered by Three.js + Svelte + SvelteKit.

Developers do spend the time to visualize aspects of their code but rarely the logic itself. They visualize other aspects of their software that are important, implicit, and hard to understand.

Here are some visualizations that I encounter often in serious contexts of use:

• Various ways to visualize the codebase overall.
• Diagrams that show how computers are connected in a network
• Diagrams that show how data is laid out in memory
• Transition diagrams for state machines.
• Swimlane diagrams for request / response protocols.

This is the visual programming developers are asking for. Developers need help with those problems and they resort to visuals to tackle them.

My goal for this book is simple: I want to take a look at phenomena that naturally occur in the physical world and figure out how to write code to simulate them.

A work in process of mapping the creative coding community around the world.

Beware of bugs in the above code; I have only proved it correct, not tried it.

Unit is a general-purpose visual programming system built for the future of interactivity.

All-in-one / Tactile / Sandboxed / 0 Setup / Auditable / Reprogrammable / Structured Editing / Meta-Programming / Private / Full Stack / Code + Layout / Open Source / Components / Reactive / Multimodal / Shareable / General / No Context Switch / Typed / Ergonomic / Handcrafted / Live / Customizable / Explorable / Visual / Dataflow / Expressive / Multiplayer / Physical / Mobile

[Atkinson] was just putting the finishing touches on the optimization when it was time to fill out the management form for the first time. When he got to the lines of code part, he thought about it for a second, and then wrote in the number: -2000.

I'm not sure how the managers reacted to that, but I do know that after a couple more weeks, they stopped asking Bill to fill out the form, and he gladly complied.

There’s still undoubtably a place for throwaway prototypes, but that doesn’t mean production code can’t learn a thing or two from the prototype mindset.

...We don’t build ‘a web application’, we build hundreds of features, services & components that unite to form an application. Each of these chunks exists along [the pace layer] spectrum, and don’t have to be placed in the production camp. Not from day one. We can play with the form.

On one side, an army of developers whose interests, responsibilities, and skill sets are heavily revolved around JavaScript.

On the other, an army of developers whose interests, responsibilities, and skill sets are focused on other areas of the front end, like HTML, CSS, design, interaction, patterns, accessibility, etc.

So much about [Gerhard Richter's painting process] reminds me of designing and building for the Web: The unpredictability, the peculiarities of the material, the improvisation, the bugs, the happy accidents. There is one crucial difference, though. By using static wireframes and static layouts, by separating design and development, we are often limiting our ability to have that creative dialogue with the Web and its materials. We are limiting our potential for playful exploration and for creating surprising and novel solutions. And, most importantly, we are limiting our ability to make conscious, well-informed decisions going forward. By adding more and more layers of abstraction, we are breaking the feedback loop of the creative process.

If GitHub Gists could run
And AWS Lambda was fun

Val Town is a social website to write and deploy TypeScript. Build APIs and schedule functions from your browser.

...Vals are small JavaScript or TypeScript snippets of code, written in the browser and run on our servers. Create scheduled functions, email yourself, and persist small pieces of data — all from the browser

Intellectually I knew that the question I should be asking was: if I invest X hours into migrating to a new editor, will I make those X hours back in increased productivity, and over what time period Y? While a precise answer to this isn’t possible, we can often make decent guesses.

...I also think that there is a place for sharpening one’s tools just for its own sake. Especially as we get older, and our responsibilities increase, anything related to our work can start to feel like a burden. Sometimes even a small amount of time invested in sharpening our tools can bring a bit of joy and restore motivation.

Whatever the outcome we’re looking for from tool sharpening, it seems to me that the most important factor is to think explicitly about why we’re doing it, and what we hope to achieve in so doing.

How do artists and scientists work? The same.

const rx = /[\s,\]\[\(\)]+/g;
const counts = {};
for (const file of Deno.args)
  for (const x of (await Deno.readTextFile(file)).split(rx))
    counts[x] = 1 + counts[x] || 1;
const total = Object.values(counts).reduce((a, b) => a + b, 0);
let entropy = 0;
for (const c of Object.values(counts)) {
  const p = c / total;
  entropy -= p * Math.log2(p);
}
console.log(entropy);

Here’s the scenario: I’m looking at a big system with several micro services, several data stores, a pub-sub queue, and integrations with several APIs. I have some questions I need to answer, ranging from “how much work would it take to replace one of the external APIs with a similar service from a different vendor?” to “which parts of this system are actually necessary to do some subset of its operations” to “what does this subset of services even do?” I don’t have access to anyone who designed or worked on the system. I do have some architecture documentation, but it’s for an older version of the system — I don’t actually know how accurate that documentation is.

In order to answer these questions, I want to make a map of the major components and how they call each other. My weapon of choice here is Obsidian, because of the way its visualization tools work.

...I’ll start with a list of the components I want to map...[Then] I turn that list into a set of notes, one for each service...[And finally,] once I’ve made that set of interlinked notes, I can switch over to graph view and see what’s basically a directed graph of the system.

I always loved the visual aesthetic of dithering but never knew how it’s done. So I did some research. This article may contain traces of nostalgia and none of Lena.

Even among front-end developers, few people actually grok this mental model of a user. It's why most React(-like) apps in the wild are spaghetti, and why most blog posts about React gripes continue to miss the bigger picture. Doing React (and UI) well requires you to unlearn old habits and actually design your types and data flow so it uses potentially invalid input as its single source of truth. That way, a one-way data flow can enforce the necessary constraints on the fly.

The way Stanley likes to encode and mutate his data is how programmers think about their own program: it should be bug-free and not crash. The mistake is to think that this should also apply to any sort of creative process that program is meant to enable. It would be like making an IDE that only allows you to save a file if the code compiles and passes all the tests.

A Code Graph is a visual representation of a codebase as a Knowledge Graph that helps one explore entities in code (functions, variables, classes) and their relationships. By mapping out these connections, it becomes easier to understand the structure and flow of the code, identify potential issues, and improve overall code quality.

The concept of representing code as a graph data structure has its roots in the early days of software engineering when researchers explored ways to model and analyze program structure and behavior using graph-based techniques. Modern Code Graphs, incorporating Knowledge Graphs and Large Language Models (LLMs), are a recent development.

• Improved Understanding: Helps trace the flow of data through functions and identify interconnected components.
• Impact Analysis: Assesses the ripple effects of code changes, predicting potential issues before they arise.
• Autocompletion: Suggests relevant functions, variables, and types based on the current context.
• Code Search: Searches for functionalities not just by keywords, but by understanding the relationships between code elements.

Build software faster in an IDE designed for pair-programming with AI.

A succinct way I’ve framed the split is that a front-of-the-front-end developer determines the look and feel of a button, while a back-of-the-front-end developer determines what happens when that button is clicked.

Great software starts on the command line. Warp is the terminal reimagined with AI and collaborative tools for better productivity.

Color carries a huge amount of information. Color draws our attention. Color distinguishes things. And we just use it to distinguish syntax.

Nothing wrong with distinguishing syntax. It's the "just" that bothers me. Highlighting syntax is not always the most important thing to us. The information we want from code depends on what we're trying to do. I'm interesting in different things if I'm writing greenfield code vs optimizing code vs debugging code vs doing a code review. I should be able to swap different highlighting rules in and out depending on what I need. I should be able to combine different rules into task-level overlays that I can toggle on and off.

TabFS is a browser extension that mounts your browser tabs as a filesystem on your computer.

...This gives you a ton of power, because now you can apply all the existing tools on your computer that already know how to deal with files -- terminal commands, scripting languages, point-and-click explorers, etc -- and use them to control and communicate with your browser.

Now you don't need to code up a browser extension from scratch every time you want to do anything. You can write a script that talks to your browser in, like, a melange of Python and bash, and you can save it as a single ordinary file that you can run whenever, and it's no different from scripting any other part of your computer.

For some of us—isolates, happy in the dark—code is therapy, an escape and a path to hope in a troubled world.

...Moving through that jumble [of the command line]—with all of its perverted poetics of grep and vi and git and apache and *.ini—*and doing so with a fingers-floating-across-the-keyboard balletic grace, is exhilarating. You feel like an alchemist. And you are. You type esoteric words— near gibberish—into a line-by-line text interface, and with a rush not unlike pulling Excalibur from the stone you've just scaffolded a simple application that can instantly be accessed by a vast number of humans worldwide.

...I find peace in the dark mess of that world. Code and servers are a home to me in a way that's difficult to explain to anyone for whom they are not.

The interesting thing is Member(Y, Arr). Y wasn’t defined yet! So Picat finds a value for Y that makes the equation true. Y could be any of a, b, or c. Then the line after that makes it impossible for Y to be a, so this prints either ab or ac. Picat can even handle expressions like member(a, Z), instantiating Z as a list!

Planning pushes this all one step further: instead of finding variable assignments that satisfy equations, we find variable mutations that reach a certain end state. And this opens up some really cool possibilities.

Observable Framework is an open-source static site generator for data apps, dashboards, reports, and more. Framework includes a preview server for local development, and a command-line interface for automating builds & deploys.

You write simple Markdown pages — with interactive charts and inputs in reactive JavaScript, and with data snapshots generated by loaders in any programming language (SQL, Python, R, and more) — and Framework compiles it into a static site with instant page loads for a great user experience.

...Framework includes thoughtfully-designed themes, grids, and libraries to help you build displays of data that look great on any device, including Observable Plot, D3, Vega-Lite, Graphviz, Mermaid, Leaflet, KaTeX, and myriad more. (And for working with data, don’t forget about Arquero, DuckDB, and SQLite, too.)

Telling web designers they don't need to worry about code is like telling architects they don't need to worry about steel, wood or physics. [Twitter]

I still believe this. Does that mean designers need to know how to implement designs in code? Do architects need to be able to lay a block foundation or hang drywall? No.

Designers need to understand and work with the grain of the medium for which they’re designing. For the web, that means understanding important concepts related to how things play out in the browser.

...It’s also important to recognize that static design tools are not the browser and can’t articulate many dimensions of a user experience...The best thing any designer can do is to communicate and closely collaborate with the people who are building things in the actual medium. Designers who foster good relationships with developers will learn what they need to about code, and the final product will greatly benefit from that collaboration.

At Vercel, we've developed Geist, a typeface specifically designed for developers and designers. We began by creating a monospace version that prioritized readability and seamlessly integrated into coding environments.

After perfecting the monospace variant, we expanded Geist into a Sans version, adding versatility to its capabilities.

Geist embodies our design principles of simplicity, minimalism, and speed, drawing inspiration from the renowned Swiss design movement.

With precision, clarity, and functionality at its core, Geist enhances the visual experience of developers and designers, empowering them to effectively communicate their ideas.

As my experience and confidence as a developer have grown, I’m more willing to remove a fence. Even though I didn’t know it had a name before a few weeks ago, “Chesterton’s Fence” is real. I’ve often been owned by failing to think this way when re-writing code.

It’s not always possible to chase down the exact reason a fence is there. The person who put it there may have moved on from the project. Because I’ve been working on CodePen for so long, I find fences I built five years ago, and I have no memory of why I put them up. That’s okay. I just need to do my best to uncover why.

The important part is not to assume that I know better than the person who made the original decision and take into account nuances or second-order effects that aren’t obvious to me.

Be sure you’ve found a better reason than “because I know better” before you delete a fence.

What you are looking at is an scroll-locked iframe that links to a quote I picked out of my blog post “Notes on Comparative Psychology.” You can use Open Transclude anywhere you can drop an <a> tag on your own site.

Open Transclude:

• Works anywhere on your own domain
• Compatible with most static site generators / templating engines
• 12 lines of HTML, 80 lines of SCSS, 22 lines of JS (4.5 kb total)
• Has 0 dependencies — this is native web technology

Open Transclude is extremely simple, and the heaviest part of the code is the CSS, which you can simplify at your whim. That’s why I am referring to it as a UX pattern. This is not a protocol. The code is really a commodity. What’s interesting about it is the idea and the design, and this is just one viable implementation! Feel free to adapt it however you like.

The principal improvement over a block quotation is sense of context.

Creative code golfing.

It’s a game we’d been dreaming of for years: a giant rube goldberg machine builder in the style of the classic Incredible Machine games, made of a patchwork of machines created by individual xkcd readers.

...Sometimes an idea feels like it emerges fully-formed, but when you start talking about it, you realize there’s still a dizzying array of decisions to make. Thus ensued 5 days of brainstorming to discover each of us had slightly different core beliefs about what this comic should be:

• Where do the balls come from?
• Does everyone see the same machine? What is its purpose?
• How can players interact with it?
• And most importantly… why do they?

It’s true that a component library may reflect the state of the live, implemented design patterns. But that doesn’t change the reality for other contributors to the system: if they’re unable to work within the component library, their work continues to evolve in their own environments. Designers will iterate on the design system as it exists in the artboards of their visual standards — because for them, that’s the source of truth.

Suggesting otherwise obscures the multiple workflows your teams are trying — and occasionally, struggling — to coordinate. It’s one of the surest ways that hyperobject feeling can creep in. Everyone’s interacting with “their” slice of the design system, but nobody’s able to see the impact of their work across the entire platform.

I wrote this zine for people who have been using git for years and are still afraid of it. As always – I think it sucks to be afraid of the tools that you use in your work every day! I want folks to feel confident using git.

My goals are:

• To explain how some parts of git that initially seem scary (like “detached HEAD state”) are pretty straightforward to deal with once you understand what’s going on
• To show some parts of git you probably should be careful around. For example, the stash is one of the places in git where it’s easiest to lose your work in a way that’s incredibly annoying to recover from, and I avoid using it heavily because of that.
• To clear up a few common misconceptions about how the core parts of git (like commits, branches, and merging) work

Each year for April Fools’, rather than a prank, we like to create a project that explores the way that humans interact at large scales. This year we came up with Place, a collaborative canvas on which a single user could only place a single tile every five minutes. This limitation de-emphasized the importance of the individual and necessitated the collaboration of many users in order to achieve complex creations. Each tile placed was relayed to observers in real-time.

Multiple engineering teams (frontend, backend, mobile) worked on the project and most of it was built using existing technology at Reddit. This post details how we approached building Place from a technical perspective.

Even today, we still have limited options when we want to layer additional meaning on top of code. Syntax highlighting was invented in 1982 to help children to code in BASIC. But beyond colors, most editors must communicate with developers through their interfaces — hovers, underlines, and other graphical decorations.

Monaspace offers a more expressive palette for code and the tools we use to work with it.

Embed authorship in text while preserving its readability and portability.

Chatbot Arena is an open-source research project developed by members from LMSYS and UC Berkeley SkyLab. Our mission is to build an open platform to evaluate LLMs by human preference in the real-world.

The problem with Test-Driven Development is that you have to think about what you want the code to do before you write it. And that ruins the surprise.

In this paper, we aim to answer a long-standing open problem in the programming languages community: is it possible to smear paint on the wall without creating valid Perl?

Recently I’ve had a few opportunities to use code to create design. In two of my bigger projects at The Wall Street Journal, writing code has led to new ideas. Problems that typically plague early designs — e.g. “how does this look with real content?” — are easy to solve. By exploring visual ideas directly in code, I’ve started to see the amazing potential of code as a design tool.

Think about all the things they've told you that you 𝑛𝑒𝑒𝑑. HTML is NOT the answer!

🅸🆃 🅸🆂 🅰🅻🅻 🅻🅸🅴🆂!

Taught that programming—or the worse "developing software"—is like a routine engineering activity, many find difficulty seeing writing as a model or even a metaphor for programming. Writing is creative, it is self-expression, it is art, which is to say it isn't a science and unlike science and engineering, it isn't a serious activity. Judgments like this, though, are easiest made by people who don't seriously engage in making both science and art. Art, engineering, and science are—in that order—part of a continuum of finding truth in the world and about ourselves.

When I started programming, XML was going to replace everything. HTML with XHTML, validation with DTD, transformation and presentation with XSLT, communication with SOAP.

...Turns out, XML was not the future. It was mostly technical debt.

It was useful for things like documents, and I believe the most successful use of it are still MS Office and LibreOffice file formats. They are just zips of XML.

I was lucky to learn this lesson very early in my career: there is no silver bullet, any single tool, no matter how good it is, must be evaluated from the engineering point of view of pros and cons. Everything has a cost, and implies compromises. It's a matter of ROI. Which is hard to evaluate without experience.

Bottom line, time is once again the great equalizer, there is no substitute to observe how a complex system evolves, no matter your model of the world.

All in all, we are likely looking at 50 million+ lines of code active to open a garage door, running several operating system images on multiple servers.

1. You don’t need hundreds of engineers to build a great product.
2. Simple Outperformed Smart.
3. Our highest impact findings would always come within the first and last few hours of the audit.
4. Writing secure software has gotten remarkably easier in the last 10 years.
5. All the really bad security vulnerabilities were obvious.
6. Secure-by-default features in frameworks and infrastructure massively improved security.
7. Monorepos are easier to audit.
8. You could easily spend an entire audit going down the rabbit trail of vulnerable dependency libraries.
9. Never deserialize untrusted data.
10. Business logic flaws were rare, but when we found one they tended to be epically bad.
11. Custom fuzzing was surprisingly effective.
12. Acquisitions complicated security quite a bit.
13. There was always at least one closet security enthusiast amongst the software engineers.
14. Quick turnarounds on fixing vulnerabilities usually correlated with general engineering operational excellence.
15. Almost no one got JWT tokens and webhooks right on the first try.
16. There’s still a lot of MD5 in use out there, but it’s mostly false positives.

Here's a trick question: How do we get people to understand programming?

Khan Academy recently launched an online environment for learning to program. It offers a set of tutorials based on the JavaScript and Processing languages, and features a "live coding" environment, where the program's output updates as the programmer types.

Because my work was cited as an inspiration for the Khan system, I felt I should respond with two thoughts about learning:

• Programming is a way of thinking, not a rote skill. Learning about "for" loops is not learning to program, any more than learning about pencils is learning to draw.
• People understand what they can see. If a programmer cannot see what a program is doing, she can't understand it.

Thus, the goals of a programming system should be:

• to support and encourage powerful ways of thinking
• to enable programmers to see and understand the execution of their programs

A live-coding Processing environment addresses neither of these goals. JavaScript and Processing are poorly-designed languages that support weak ways of thinking, and ignore decades of learning about learning. And live coding, as a standalone feature, misses the point.

Alan Perlis wrote, "To understand a program, you must become both the machine and the program." This view is a mistake, and it is this widespread and virulent mistake that keeps programming a difficult and obscure art. A person is not a machine, and should not be forced to think like one.

How do we get people to understand programming?

We change programming. We turn it into something that's understandable by people.

This is a silly idea and should in no way be used for anything sensible.

One of the reasons XML (and XHTML) fell out of favour is that they are unforgiving. Miss a /? Your site is broken. Forget to close an element? Your site is broken. Incorrectly escape something? Your site is broken. Mismatched elements? Your site is broken.

HTML, by contrast, is rendered by engines which are tolerant. Made a mistake in your HTML? The browser will do its best to display the page.

One area where XML and XSL shine is if you are working with highly structured and regular data and want to display it in a more human-friendly way.

But, nowadays, there's very little reason to use XML for display purposes. Unless you want to get frustrated.

"If you develop a program for a long period of time by only adding features but never reorganizing it to reflect your understanding of those features, then eventually that program simply does not contain any understanding and all efforts to work on it take longer and longer.” — Ward Cunningham

This is a programming language based on three paradigms:

• Tacit programming
• Stack-oriented programming
• Array programming

The main feature of the language is its avoidance of any naming of any sort. True to this maxim, the language itself doesn't have a name. "The namingless programming language" is a definition.

Since there is only one such language in existence, it doesn't need a name.

i_^_b_H_i_cpp^_)_V_b_v_J_^_E_H_leafL_==^_)_V_H_Z_Z_^_)_V_H_I_^_E_1^_2^_#_G_Z_Z_^_E_1^_2^_#_H_$_L_-^_G_m_G_&_&_

Maybe the era of search-first is just over? What I mean is this - you could argue that today we start our queries in search (just like we used to start our search in directories many moons ago). Whether it’s voice search, Google search etc we start there.

But you could argue that we’re entering an era where we start our queries with an LLM/assistant interface. Something that results in search some of the time - but NOT all the time. Some times it results in novel, new interfaces - whether it’s a just-in-time UI that is assembled to support your task completion or whether it’s a collaborative document / code environment.

In racing, like other communities of competence, you’ll often hear the saying: Slow is smooth. Smooth is fast. This is that, but for making software. Building for quality, building for readability, and sweating the details is a slow, smooth process. One that gets you to release quicker than the frantic thrashing you hear about from stereotypical crunch sessions.

So I’ve been sweating those details a lot with ONCE #1. Regularly reading through the entire 7,412 lines of code to polish spacing, pick slightly better model names, and correct cohesion issues. And every time I do, I usually also find other small quality issues that’ll lead to a better product which fewer people will have issues with.

The metaphor for this we’ve been using internally is taken from watch making. We want ONCE #1 to have Patek levels of finishing, because we’re shipping this product with an exhibition case back. Get that knurling right!

Go is often described as a simple language. It is not, it just seems that way. Rob explains how Go's simplicity hides a great deal of complexity, and that both the simplicity and complexity are part of the design.

I recently built flashcasts, which delivers spaced-repetition software via podcast feeds.

There are plenty of excellent off-the-shelf SRS algorithms out there, but I needed something (1) optional, (2) debuggable, and (3) cheap.

A programming language whose virtual machine is Olympus. Instead of registers, we have a set of gods, each of which will do specific things for us if we ask them in the right way...Each line of code is written as an invocation: a request to a god.

Avoiding common styling problems is simple. And you only need efficient CSS. Nothing more.

ECSS sets simple rules for simple styling. No more naming everything, no more technological dependencies. Only intentional, consistent, simple, expressive, predictable, sustainable CSS.

Variable names fall along a spectrum of how generally useful the thing you're labelling is. At one end of the spectrum you have pragmatic labels that refer to some one-off thing that you need to track in the problem in front of you. At the other end of the spectrum you have labels for things that come up again and again in multiple problems.

I'm going to call the first type handles because they are simple one-time attachments to a particular thing in the world.

In contrast, the second type of variable name has been used so much to refer to a particular thing that a strong association with the thing has accreted around the variable itself. I think of these as sigils because they've been charged with meaning through repeated use.

No matter how fancy your Figma file is or how beautiful and lovingly well organized that Storybook documentation is; the front-end is always your source of truth. You can hate it as much as you like—all those weird buttons, variables, inaccessible form inputs—but that right there is your design system.

...being honest about this is the first step to fixing it.

Key Event Viewer: View KeyboardEvents on a <input type="text"> element.

Mouse Event Viewer: View MouseEvents on a set of overlapping <div>s.

Focus Event Viewer: View FocusEvents between two <input> fields enclosed in a <div>.

1. They give PMs an excuse to not make hard decisions, such as completely removing a feature.
2. The codebase becomes more complex and harder to maintain.
3. Testing becomes harder (and lower quality) - figuring out what combination of feature flags needs to be supported.

I’d be willing to bet that if you are considering a rewrite, it’s probably the wrong idea.

A lot of the value that an agency like mine brings to a project is that perspective. When a client comes to us with an untenable codebase, we know how to maneuver through them, identify the most critical issues, and triage different parts for a more selective, focused refactoring that emphasizes incremental change. In other words, it’s our job to understand what we’re working with and identify the places where we can have the biggest impact.

It’s a mark of a seasoned programmer to have the ability to do that and the willpower to resist the temptation of a rewrite.There’s a reason that Joel Splosky named it the single biggest strategic mistake you can make. The value that you add to a codebase is usually going to do little more than match the effort that’s already gone in. There are definitely cases when a rewrite is necessary, but they are very rare.

• Devs shouldn't be isolated or left to just code. Bypassing TPMs, PMs, and talking directly to the customer always reveals more about the problem, in less time, and with higher accuracy.
• Pencil and paper are the best programming tools and vastly under used.
• 90% – maybe 93% – of project managers, could probably disappear tomorrow to either no effect or a net gain in efficiency.

Is code synesthesia a thing? If so mine is visceral, kinaesthetic.

Maybe really great engineers have a totally different way of seeing code, in the same way that great chess players feel patterns and potential fields on the board?

Maybe the design of my code editor should learn from great engineers and amplify whatever synesthetic intuitions they might have: inner loops should appear crisper on the screen; editing compound conditionals should wobble just enough to make you seasick.

A rule of thumb is that the importance of a blog in your feed reader is inversely proportional to their posting cadence. Prioritise the blogs that post only once a month or every couple of weeks over those that post every day or multiple times a day...Building up a large library of sporadically updated blogs is much more useful and much easier to keep up with than trying to keep up with a handful of aggregation sites every day.

give each pixel a random Pokemon type, and then battle pixels against their neighbors, updating each pixel with the winning type (using the Pokemon type chart) we quickly see areas of fire > water > grass > fire, electric sweeping over, ground frontiers taking over etc etc

An API should be easy to learn and write to, and hard to misuse. Your API will also need to evolve, and a good design takes this into account.

We will continue to see the Pyramids as a height of human achievement through the next millennium. Shakespeare will stand the test of time. Einsteins theories will never lose their magnificent intellectual splendour. We remember the scientific discoveries and the story of a serpent swallowing its tail as the metaphor for benzene or Einstein’s magnificent thought experiment about standing on top of a light beam traveling as an elevator. We even will honour the decisions taken in history, Napoleon’s defeat in Waterloo by the Duke of Wellington or Churchill’s decisions in World War II or even the business decisions by Andy Grove or Rothschild or J P Morgan.

Code though, code won’t stand the test of time. Nobody will be praising the beauty of the code that sent the first man to walk on the moon, or the code that enabled a 100 billion messages to be sent between all of us, daily. Once writ down and made concrete it becomes invisible. We use it like disposable bricks that make up an edifice.

Your locally hosted one-stop-shop for all your PDF needs.

npm’s culture presents a major problem for global software security. It’s grossly irresponsible to let dependency trees grow to thousands of dependencies, from vendors you may have never heard of and likely have not critically evaluated, to solve trivial tasks which could have been done from scratch in mere seconds, or, if properly considered, might not even be needed in the first place.

If we see ‘lines of code’ as ‘lines spent’, then when we delete lines of code, we are lowering the cost of maintenance. Instead of building re-usable software, we should try to build disposable software.

I don’t need to tell you that deleting code is more fun than writing it.

To write code that’s easy to delete: repeat yourself to avoid creating dependencies, but don’t repeat yourself to manage them. Layer your code too: build simple-to-use APIs out of simpler-to-implement but clumsy-to-use parts. Split your code: isolate the hard-to-write and the likely-to-change parts from the rest of the code, and each other. Don’t hard code every choice, and maybe allow changing a few at runtime. Don’t try to do all of these things at the same time, and maybe don’t write so much code in the first place.

Memory is fallible and degrades surprisingly quickly. Relying on your memory too much in your work leads to errors, both because your recall can be wrong, but also because software changes. What you remember might not be correct any more.

What’s more important is gut feeling. The human mind is great at spotting patterns and deviations from patterns…Don’t memorise the words. Look at the code. Treat the code like a food or drink you want to savour. Swish it in your mouth and remember the feeling that nice code gave you.

Meet Devin, the world’s first fully autonomous AI software engineer.
‍
Devin is a tireless, skilled teammate, equally ready to build alongside you or independently complete tasks for you to review.

With Devin, engineers can focus on more interesting problems and engineering teams can strive for more ambitious goals.

https://bitbang.social/@NanoRaptor/111699576526610669

A couple days ago, I posted about the recent CSS WG resolution to add an if() function to CSS. Great as it may be, this is still a long way off, two years if everything goes super smoothly, more if not. So what can you do when you need conditionals right now?

You may be pleased to find that you’re not completely out of luck. There is a series of brilliant, horrible hacks that enable you to expose the kinds of higher level custom properties that conditionals typically enable.

The instinctive reaction many developers have when seeing hacks like these is “Nice hack, but can’t possibly ever use this in production”. This sounds reasonable on the surface (keeping the codebase maintainable is a worthy goal!) but when examined deeply, it reflects the wrong order of priorities, prioritizing developer convenience over user convenience.

User needs come before the needs of web page authors, which come before the needs of user agent implementors, which come before the needs of specification writers, which come before theoretical purity.

• Avoid weasel words
• Follow patterns religiously
• Don’t cheap out on characters
• Call things the same thing
• Don’t name internal projects
• When things change, change their names

SQLime is an online SQLite playground for debugging and sharing SQL snippets.

This CSS module describes a mechanism for styling arbitrary ranges of a document identified by script.