Software is misunderstood. It can feel like a discrete thing, something with which we interact. But, really, it is the intrusion into our world of something very alien. It is the strange interaction of electricity, semiconductors, and instructions, all of which somehow magically control objects that range from screens to robots to phones, to medical devices, laptops, and a bewildering multitude of other things. It is almost infinitely malleable, able to slide and twist and contort itself such that, in its pliability, it pries open doorways as yet unseen.

the clearing price for software production will change. But not just because it becomes cheaper to produce software. In the limit, we think about this moment as being analogous to how previous waves of technological change took the price of underlying technologies—from CPUs, to storage and bandwidth—to a reasonable approximation of zero, unleashing a flood of speciation and innovation. In software evolutionary terms, we just went from human cycle times to that of the drosophila: everything evolves and mutates faster.

A software industry where anyone can write software, can do it for pennies, and can do it as easily as speaking or writing text, is a transformative moment. It is an exaggeration, but only a modest one, to say that it is a kind of Gutenberg moment, one where previous barriers to creation—scholarly, creative, economic, etc—are going to fall away, as people are freed to do things only limited by their imagination, or, more practically, by the old costs of producing software.

We have almost certainly been producing far less software than we need. The size of this technical debt is not knowable, but it cannot be small, so subsequent growth may be geometric. This would mean that as the cost of software drops to an approximate zero, the creation of software predictably explodes in ways that have barely been previously imagined.

Entrepreneur and publisher Tim O’Reilly has a nice phrase that is applicable at this point. He argues investors and entrepreneurs should “create more value than you capture.” The technology industry started out that way, but in recent years it has too often gone for the quick win, usually by running gambits from the financial services playbook. We think that for the first time in decades, the technology industry could return to its roots, and, by unleashing a wave of software production, truly create more value than its captures.

Software production has been too complex and expensive for too long, which has caused us to underproduce software for decades, resulting in immense, society-wide technical debt.

technology has a habit of confounding economics. When it comes to technology, how do we know those supply and demand lines are right? The answer is that we don’t. And that’s where interesting things start happening. Sometimes, for example, an increased supply of something leads to more demand, shifting the curves around. This has happened many times in technology, as various core components of technology tumbled down curves of decreasing cost for increasing power (or storage, or bandwidth, etc.).

Suddenly AI has become cheap, to the point where people are “wasting” it via “do my essay” prompts to chatbots, getting help with microservice code, and so on. You could argue that the price/performance of intelligence itself is now tumbling down a curve, much like as has happened with prior generations of technology.

it’s worth reminding oneself that waves of AI enthusiasm have hit the beach of awareness once every decade or two, only to recede again as the hyperbole outpaces what can actually be done.

in the article they're talking about how live-coding is inherently harder for people who have been working in the industry longer. which sounds.....not right? like why would more experience with coding make you worse at interviewing? it's because these interviews filter for people who spend their free time practicing coding prompts and algorithms for fun. and people who work 9-5 jobs and have lives outside of work just don't do that, so they're inherently going to be worse at these type of interviews.

Essentially the reason Electron apps are so heavy is they run on a browser, not on an operating system.In the beginning, programs ran directly on hardware, and things were good. (e.g. Pretty much every game would ship with a custom bootloader that knew how to address the hardware and exposed this to the program, you didn’t - couldn’t - have anything else running at the same time.)Later on, programs ran on the operating system, and things were okay. Operating systems abstracted over all the possible hardware configurations in an acceptable way and users got the benefit of running multiple programs simultaneously without too much of a performance cost.Now, programs run on the browser, itself a program running on the operating system. Because the browser wants to be a platform for any other program, it has to hook into almost every part of the operating system, so that it can support almost any program. This necessarily brings with it enormous bloat - in effect you’re running one general-purpose pseudo-OS framework per program.

I do a pretty good job of channeling my procrastination into adjacent creative tasks which, in the end, influence, shape, and improve the chunks of work I do complete. And that looks like productivity from the outside. But trust me, from the inside, it usually just feels like avoidance and procrastination. But I’ve learned to accept that’s the cost of doing the kind of work I feel good at, so I let it be what it is.

The particularly nice thing about coding is that it offers many little “wins”: I get a function working, I figure out a piece of design

“Can’t face work? Then cultivate some side projects — and channel your work-avoidance into fun opportunities to learn” and once you’re done, you’ll 1) have something productive to show for it, and 2) be much more fit, rested, and ready to tackle that project at work. In other words: rather than fight your penchant for procrastination, work with it. It’s a judo move: don’t fight your enemy, use its momentum against it for your benefit.

So when ex-Telltale Games designer and writer Sean Vanaman announced last month that the first game from Campo Santo, his new video game development studio, was "being both backed by and made in collaboration with the stupendous, stupidly-successful Mac utility software-cum-design studio slash app/t-shirt/engineering company Panic Inc. from Portland, Oregon," it wasn't expected, but it wasn't exactly surprising, either. It was, instead, the logical conclusion of years-long friendships and suddenly aligning desires.

"There's a weird confluence of things that have crisscrossed," he said. "One is that we're lucky in that Panic is the kind of company that has never been defined by a limited mission statement, or 'We're the network tool guys' or anything like that. I mean, we made a really popular mp3 player. Then we kind of fell into network tools and utilities, but we've always done goofy stuff like our icon changer and these shirts and all that other stuff. "I kind of love that we can build stuff, and the best reaction that we can get when we do a curveball like this is, 'That's totally weird, but also that totally makes sense for Panic.'"

"To me," Sasser said, "when you have actually good people who are more interested in making awesome things than obsessing over the business side of things or trying to squeeze every ounce of everything from everybody, then that stuff just goes easy. It's just fun. The feeling that you're left with is just excitement.

Every software framework you've ever used is in the abstraction game: it takes a general-purpose tool, picks a specific set of common use-cases, and puts up scaffolding and guard rails that make it easier to build those specific use cases by giving you less to do and fewer choices to think about. The lines between these three are blurry. Popular abstractions become standardizations.

This is also a very good reason to avoid viewport units, like vw or vh, when setting font size. Those are also static, and impossible to override by the user. At most, a value like calc(1rem + 1vw) might be acceptable, since that still contains rem as a base. Even then, however, I’d recommend using clamp() or media queries to set minimum and maximum values, as screen sizes often go far beyond what we might expect or test.

To differentiate between the two: 1rem is always equal to the browser’s font size—or, more accurately the font size of the html element. rem stands for “root em,” and the root of a webpage is the <html> tag. So, 1rem = whatever the document font size is. (Which, again, by default, is 16px, but can be overridden by the user.) em, on the other hand, is the font size of the current element.

1px is equal to whatever the browser is treating as a single pixel (even if it’s not literally a pixel on the hardware screen).

ChatGPT feels like the current aim assist debates in a lot of FPSses to me. It'll make you better at the shooting part of the game, perfect even. But, won't necessarily make you that much of a better player, because aiming is only one aspect of what makes someone good at FPSes. However, if someone is generally good enough or very good at the "not aiming" portion of the games, then having aim assist would drastically increase their overall skill.

Not all design work is done in code, prototyping tools, or sketches. Likewise, not all engineering work is done in code or technical diagrams. Natural language, text, and conversations should be some of your primary mediums for creative work.

one of the most important sub-skills for writing and conversation as a design medium is learning how to create great analogies. Douglas Hofstadter thinks that analogies are actually the core of cognition, which I buy.

the web has some amazing advantages for launching new projects, which include (but aren’t limited to): Super fast distribution and updates Cross platform Huge tooling ecosystems Enormous, worldwide community If you’re into games, awesome! If you’re into mobile or native development, that’s cool too. There are lots of platform-specific toolkits and environments to make those. There’s also a lot of effort in creating cross platform tools and community-driven projects for both domains (like Unity and Flutter). They all have their advantages, but to me, nothing beats the portability and speed of launching new websites and using web tech to get ideas out the door.

using web tech for 80-90% of my projects has a lot of skill transfer effects. Since I’m using similar tools for lots of different projects, I can still refine my core skillset no matter what I’m making. If I’m making a drawing tool concept, a game, or a text editor— I’ll can still probably build all three with React. Of course there are specific libraries or APIs I might need to learn to make each kind of project, but there’s enough in common between all the projects that I can focus on the new content instead of yakshaving and deliberating over unnecessary details.

There are also market pressures that imply focusing on web will have long term payoff, like the rise of wasm, new browsers, and collaborative apps becoming the norm.

We fully acknowledge that it’s hard to be confident in any predictions at the pace the field is moving. Right now, though, it seems we’re much more likely to see applications full of creative images created strictly by programmers than applications with human-designed art built strictly by creators.

It is sort of miraculous that modern video codecs like H.265 have made it possible to fit videos of increasing quality and resolution into shrinking amounts of space. But when it comes to software, the pattern is exactly backwards.

In software development, technical debt (also known as design debt[1] or code debt) is the implied cost of additional rework caused by choosing an easy (limited) solution now instead of using a better approach that would take longer.[2] Analogous with monetary debt,[3] if technical debt is not repaid, it can accumulate "interest", making it harder to implement changes. Unaddressed technical debt increases software entropy and cost of further rework.

Common causes of technical debt include: Ongoing development, long series of project enhancements over time renders old solutions sub-optimal.

Parallel development on multiple branches accrues technical debt because of the work required to merge the changes into a single source base. The more changes done in isolation, the more debt.

You can look at an interface and see it as a clearly signposted user journey you should follow. Or you can see it as a collection of functions and affordances to repurpose. As raw material, rather than a guided path.

Sprints don’t help organize things, they’re not a useful organizing tool, and if we were all honest with each other then we’d admit they’re designed for managers who don’t trust their employees

Good teams don’t need sprints to get good work done. They don’t need to point tickets or file receipts away once something is complete. This always leads to an endless backlog of crap anyway which is also a waste of time since they too only serve managers who are scared to say “ah yes, we have listened to this complaint and we believe it’s not important.” That’s what a backlog is; a list of useless tasks that makes people feel better.