6,686 karma · joined April 24, 2019
Weeks and month for to wait for a feedback in developing software? Are you the sloth in zootopia?
The longest cycle for feedback for me has only been hours. And that was about redesigning the core architecture of an app. Otherwise, it’s like 10 minutes cycle if it’s edit-compile-run, 5 minutes if it’s REPL (lisp, bash, python,…).
A single PC can solve a very complex simulation model in seconds, something that would require years using humans to do. Same as solving a very complicated maze. So if coupling a text generator with a proof verifier is now capable of coming up with a proof, I’m not particularly surprised. But given the cost, and the actual usefulness of the proof, I’m not particularly excited either.
But code is not a closed system, even if we do prove a lot of the internal mechanism, we still can’t know the input (noise), and whether the axiomatic foundation will hold. That’s the reason people don’t bother. The theory of computation is just too loose in its constraints. You just write enough tests to catch egregious errors.
All languages are built on top of an ISA, whether directly (assembler), or by mapping it to an abstract machine. The you have the dreaded “eval” function. Then because a lot of software lives on top of an OS, there’s all the virtualization that is going on (timesharing, virtual memory, filesystems,…). Memory safety is nice, but it doesn’t help you when the attacker send valid, but malicious data from a compromised source, or by exploiting a logic error.
And for kernel code, where everything is accessible to everyone, it’s much a matter of discipline, especially with so much hardware interrupts and syscalls from userspace going around. Most kernel code has very short lifecycle, it’s the data that is long lived, and it’s a shapeless blob in memory that you have to trust the other party kept in good shape.
If someone says that something is a risk and we should address it, I don't expect a director to ask for a specific date the risk to become a disaster. Instead, he should just add it to some todo list and slot some time to analyze it and and budget resources. AKA, doing some "management" work. You shouldn't have to explain his job. You didn't need to learn semiconductors physical properties to know that storage can fail and you need to do backup.
Just take a quick look around to see how many daily tools and utilities are actually built by experts and industries. Yes, you can put a plank on top of two concrete blocks to make a bench, but many people don’t and prefer to have good bench made, even when it’s quite easy to DIY one.
So I don’t foresee lots of people trying to make custom tools, more so to keep a subscription active.
The years was not spent on learning how to code. The years was spent on learning about what needed to be coded. And that would have spanned multiple domains. Even the most basic production level software have multiple concepts that need to be integrated. And for that, they need to be learned.
Using AI without the requisite knowledge is playing Russian roulette. It’s kinda wanting to log into a file, and not thinking about disk storage being finite, and rotating the log file gives you flexibility. That’s not related to coding, it’s just hard thinking about the problem and the constraints (or finding a good book or article).
Even with basic pseudocode and very lenient logical rules, most people won’t bother to provide a a good definition of some process, as it’s quite unnatural to be that logical. Instead, it’s mostly just playing around. When you ask the one that is supposedly 10x-ing his productivity to explain his mental model of their own projects, it’s often a wishlist instead of a real understanding of what he has built.
This is why children can easily learn enough programming to create games, because it’s a domain they can comprehend easily. Just like they can use english to write about their daily lives. It will be simple sure, but it will work.
So learning to code is fairly easy, you can easily create simple programs after a weekend. More complex programs will still use most of the same basic concepts as far as coding goes, but you will need to master more complex concepts, and that takes time. And such concepts are not about coding, they are about the nature of computing or the domain the software is created for.
This is why experienced devs only need a few days doing kata to get up to speed with a new programming language. It’s usually the same old, with slight differences. What was always needed was an understanding of computing and the ability to break down problems and create a solution that can be computed.
Coding to me is the same as drafting an engineering schematics, or writing a sheet music. It’s just a tool, not the end result.
For me it’s been: Learn more about unix through OpenBSD as a daily driver, learn how the usb and pci stack works in the kernel, refresh my knowledge about operating system, learn a simpler processor (avr) and interfacing, learn digital logic and computer organization, reignite my interest in electronics, refresh my knowledge about control systems, learn how to model dynamic systems, quick dive into robotics…
This is just basic curiosity over the last year. When I was younger and had more time, I explored 3D modeling, making games, pen-testing and reverse engineering, learning various software and platforms,…
This always reads like “writing english is solved” just because you collected snippets of famous works and have built a spell corrector.
Code is written to process data. The struggle was never to learn programming syntax (most grammar are only a few page long). The main struggle was that it’s hard to model a domain into an information system, identifying the components and their relationships, what is ingested, and what needs to be output.
Computers have integers and floats, but you need to implement units like distance, money, various counts,… The real world have words and sentences, but that needs encoding like ascii and unicode as well as the “string” concepts to make it work. Take HN, I’d bet that if you can model it in terms of data, writing code is not an issue.
That is both untrue, and should be something that occurs rarely.
Past Mid level, most dicussion in code review is centered around the conceptual level. Code is mostly use to highlight the point being made. I’ve never seen the need for someone to rewrite a patch proposed by another person. Add to it or correct misunderstandings, but never sweeping changes.
What Anthropic wants and what happens in reality are two different things. But with code I write, I do control the process.
> Eh no. You need to know about only a compressed part of it, not 100%. Do you really claim that you need to know 100% of the code?
I know the code I write, and I know how it interfaces with external modules. When those interfaces don’t function as described, I look at the code if I have access to it. When I don’t, the party in control has always good incentives to produce good documentation. That knowledge is usually good for some time (years even)
> my manager doesn't look at my code
Because that’s not his responsibility, just like he’s not responsible for bugs and crashes. He’s responsible for the project and the team and you can be pretty sure that he’s looking at all at the information about those. Imagine if his own manager ask him about some details and he answers: “I don’t know, Claude is doing it”.
The manager always has a very good stick: “Do a good job or you will be fired”. And me wanting food is well aligned to not produce buggy code. Or make my job harder in the future by writing unmaintainable code.
> Frankly, these discussions are tiring because there's a false notion that humans have to be in the loop 100% of the time
The code is written to process data. Someone needs to be aware of how it’s processed, so that when malformed data appears, we can collectively find where it happens. You can always play around with your own data (if regulation allows) but you need to respect your customers’ data. Not looking at the code jis just negligence.
And git is enough to version control some of the most complex software like the Linux Kernel, the FreeBSD operating system, QEMU, browsers like Firefox,... Git was insufficient for Facebook and Google because they wanted to put the whole org inside a single repo, which broke the assumption where decentralization in git would happen (repo level, not subtree level). Now it seems that another assumption is broken, that you wanted a version control system, not a snapshot or a rolling log.
[0] https://martinfowler.com/bliki/ArchitectureDecisionRecord.ht...
So you can get AI to produce code, but you should refine your mental model alongside it and not try to build a scaffold as that would always be too generic and wrong. As a scaffold good enough is already code. So exoskeletons mindset, more than hive mindset.
In most SPA, state is distributed with two copies floating around. Even if you do restrict the update flow, it’s still a lot of works to keep it consistent. That’s good enough when it’s partitioned and each side take care of its own state, but in most cases, the intersection is very large.
With SSR, the “page” is a dead copy. The only source of truth is the backend.
This labour was not the main bottleneck. I’m ready to bet that coding is a small part of the daily activities of a dev.
> Later when requirements change you reiterate and regenerate your prototype and continue.
That is incredibly wasteful. Requirements are set agains a world model that always evolves against its own set of constraints. Which does ties into the flexibility argument. No need to reinvent the wheel, when only a few things varies and some just stay true for years and decades..
>> The assembly itself is a matter of data and process. How each module is initialized, its lifecycle, which data it consumes, which data it produces
> This is taken care of by having modules follow the LKM model with ioctl interface as explained above.
Nope, it’s not. This is related to having a good mental model of how your software process data, not related to how you design your interface.
—-
As I said, your comments put “code” as a first place citizen, which no experience dev does. What I argue about is that it’s always about data, the rules that it follow, which will then be realized by code.
> DbC methodology is the quintessential "data-driven" programming since the pre/post/inv are predicates to establish sets of data values on which the subsequent code can operate safely
Like the one above. You don’t write code and assert which type of data that it can handle. That’s a fool errand as the outside world is naturally messy. You define the data first, and then write the code. Meaning when the data changes, the code needs to evolve. You need to have a very good mental how that changes propagate, which you won’t have of you just regenerating code.
That’s why no one builds a factory to produce factories. Although there are common elements, a factory is designed for the product it will create. So you start from the product, you don’t start from the factory. Your methodology is a framework for building factories, but with no mention of any product.
But in most web apps, interactive widgets are just little islands in the page. The higher concerns are routing, authorization,… which are already handled by the browser/server interaction.
If you take a look at "real" code out there and it's evolution, you'll find that the main thing that drives it is the set of requirements. On the other side you have the platform (standard and 3rd party libraries as well as frameworks). Add to that is the set of algorithmic techniques (including design patterns).
By analyzing the requirements, you will discern that often they're composed of sub-problems that are generic (which is where you algorithms techniques comes in). And some are already solved (libraries). Often there's a common shape to the requirements (or some of them) that can be extracted into "frameworks".
So what's left then is the assembly. But often requirements are evolving concepts. So you don't want your structure (architecture) to be that rigid. You can't really know the direction of evolution, so you try to predict it in some way and add flexibility in a few places. This is more an art, but there are general techniques that works well enough.
The assembly itself is a matter of data and process. How each module is initialized, its lifecycle, which data it consumes, which data it produces. A program is always part of an information system. Means data come in, got processed, and go out. And here is the majority of development type is consumed, ensuring that the data is correctly processed.
Programming concepts like type checking, memory safety, paradigms (oop, functional, relational,...), formal verification,... are all about data. Code always come in second place. So think hard about your data and its transformation.
That’s what I thought the article would talk about. If it were social media, I’d rather buy a cheap used phone, put the app on it, and turn it on only when I want to check something. Then it’s off. But I deleted/haven’t logged into my accounts for years now.
As for as minimal compute goes. my daily driver is an old laptop I put OpenBSD on. I also have an m1 air that I mostly use for shopping and meeting. Then an iPad for reading. But the key thing is that app and software are tools. It’s either tied to an activity (even relaxing ones) or it’s not used. No ricing or theming, just basic configuration to get the job done.