iroddis

I just bought it, and can’t wait to try it. Red Storm Rising[1] was easily one of my favourite games growing up. The combination of strategy on the war map and tactics during the encounters, weighing the pro/con of using sonar, and weaving around the thermocline was my happy place. Submarine sim games are truly a special niche, and I’m so excited to try this one out!

[1] https://en.wikipedia.org/wiki/Red_Storm_Rising_(video_game)?...

With the recent discussions around choreographic programming, and the flood of Show HN languages, this book might be of interest. Some of the languages are truly strange and unique. Transputers, concatenative stack programming, array programming, there's a lot of great stuff in here.

> For the person who only wants the notes, the sampler wins the job outright, completely. It will never play the wrong thing or at the wrong moment. For the person playing, it fails, because driving it costs more than playing, and it never touches the art at all.

This entire essay could be about AI adoption as well. Some programmers love to program, and while AI is great at producing the code, it doesn’t really viscerally appeal if one loves coding itself.

Probably made worse by the fact that _every_ VW brand car I’ve driven has read about 10% high on the speedometer. I think I’m going 100 kph, but timing using the km markers on the highway show I’m going about 90.

When I talked to the dealers, they said that the speedometers only have to be accurate +/- 10% according to the SAE specifications.

After DieselGate I assumed that the high reading was to game the fuel consumption game.

Never again, VW auto group…

It all sounds great until someone writes nested list comprehensions. They are the recommended, idiomatic way to things most sane people would use ‘map’, ‘filter’, and ‘reduce’ chains, although chains are another thing python very much dislikes.

This is really cool, and definitely needed.

Do you do any tracking of resource consumption over the runtime of a job? We have many jobs that use the requested memory only for a portion of the runtime, and are otherwise compute bound. It would be nice to be able to learn the profiles through time of jobs and layer them to get better resource utilization.

> Binary computers have two states: on and off. Every value, every decision, every process is either 1 or 0.

I’m not sure what this means. Computers are based on binary, but not everything is a single bit. Even if you wanted to use a ternary base the digit values would be 0, 1, and 2, not -1,0,1.

If anything this project is a testament to Claude’s ability to generate anything meaningful from the non-sensical requirements.

Also, you should probably want to remove the “hand-coded” claim.

The “programming is an act of externalizing a mental model” vs “a code review is reverse engineering the model, then verifying its reasoning” really hit home. Even before AI code reviews required a lot of mental effort for me. AI has made an already difficult process much more prevalent.

> the concept of getting a good grade on a test as a happier concept than kissing a girl for the first time.

Were the concepts weighted by response counts? I’d imagine a good grade is a happy concept for everyone, but kissing a girl for the first time might only be good for about 50% of people.

This is amazing, such a nice presentation. It reminds me of the Neural Network Zoo [1], which was also a nice visualization of different architectures.

[1] https://www.asimovinstitute.org/neural-network-zoo/

That’s true, but the travel distance of the braces or the double quotes from the home row is much less than the travel distance from the parentheses. Just using shift isn’t the problem, it’s how far parens are from the normal hand position.

For people that use Lisp extensively, do you find the chording requirements of parentheses (shift-9 or shift-0) annoying? It feels like very bad ergonomics, considering how frequently the characters are used.

Do you use a keyboard with mappings to make it easier? Rely on the editor to insert them for you?

+1 for vim slime. It’s not only amazing for programming in REPL languages. Since you can send anything from the buffer to another pane, it can be used to execute commands (send some rows from a cookbook to a remote shell), copy and paste segments of a local file to a remote source, and lots of other things. It’s a great example of doing something simple (send selections to another tmux/screen pane) that can be used in all kinds of useful ways. Very much the unix philosophy.

I think this case was the browser was active, but not the tab, so the browser reports that.

Many, many telemetry metrics have been added in the name of power and efficiency. If a page refreshes every 30 seconds, is it still worthwhile doing it when the tab isn’t active? It would be better to wait until the tab is active again, then refresh immediately.

That being said, all of these capabilities are a privacy nightmare, only increasing the precision of browser fingerprinting and user monitoring. Firefox could have taken a stance on refusing to implement them, but I don’t think it has an easy opt out.

I suspect the author is assuming that users don’t want to have to learn a substantially different way to manage their code. Fossil and pijul are both interesting alternatives, but quite different from git.

I don’t think coding is dead, but I do find AI deeply demotivating. It feels like continuing to play a game after the cheat codes have been enabled.

You could be an amazing player, but everyone will point out the cheat codes are on. The last refuge will be deeply niche programming or areas not well represented in, or not generalizable from, the vast training corpus.

The Children of (insert adjective) series by Adrian Tchaikovsky is really, really good, especially the second in the series. Good science fiction where the aliens are very alien are hard to come by.

This was a great read, and perfectly conveyed the combination of passion and anger of every WH player I’ve ever met has had.

Given the time, it’s hard not to view this same argument through the lens of AI. People who love crafting their creative works will still do it, even when AI can do it. They will still inspire others because they demonstrate what humans can do, and what we can aspire to.

It sounds, as you point out, that he is aware of the tendency to typos and has an idea on how to guard against it. I’ve built up a similar portfolio of techniques and best practices to guard against my own shortcomings, and most of the friction I encounter is when the team I work with doesn’t have the same viewpoints on correctness and tests.

Languages like Python are the worst for exacerbating issues. Perl at least would parse the entire codebase and do some validation. Python doesn’t evaluate until runtime, meaning that unless you have 100% test coverage of all functions and branches a typo could cause an issue long after the process started.

As others have mentioned it sounds like you co-worker has good ideas. Adding test coverage, being stricter about configs (don’t ignore known keys, validate structure … as much as people hat XML, DTDs are an amazing help for catching config errors) are all things that will pay off down the road.

Long story short, instead of looking at your coworkers suggestions as a way to guard against their mistakes, take some time to understand that they live in a more chaotic worldview than you do, and have strong experience in dealing with it. Heck, put them in charge of QA processes. They sound like they’ve got the experience, and will feel better when that experience is appreciated.

Congrats on the progress thus far! I love aspirational languages, so please keep going.

That being said, as someone who struggles with maintaining large amounts of context when I’m debugging, I’d find context-specific execution hard to follow and debug. As a concrete example, the switch to an Admin context could appear far away from the call to GetPermissions without any obvious way to figure that out. Contexts end up being a sort of global state.

If you continue with this route, it would be nice if there was a way to print out the stack of the current contexts in play and where they were set in the code.

Are contexts scoped at all? Can they be layered?

Except function colouring is a symptom of two languages masquerading as one. You have to choose async or sync. Mixing them is dangerous. It’s not possible to call an async function from sync. Calling sync functions from async code runs the risk of holding the run lock for extended periods of time and losing the benefit of async in the first place.

I don’t have anything against async, I see the value of event-oriented “concurrency”, but the complaint that async is a poison pill is valid, because the use of async fundamentally changes the execution model to co-operative multitasking, with possible runtime issues.

If a language chooses async, I wish they’d just bite the bullet and make it obvious that it’s a different language / execution model than the sync version.

It looks interesting, a lot like cellular automata (game of life), but focusing on structures rather than individual cells.

I still subscribe to Linux and Admin magazines, and look forward to getting them. They are nostalgic while still filled with genuinely useful information. There is something categorically different in the experience of sitting down and reading curated articles vs consuming an endless stream of updates. Both are worthwhile, and I’m glad both are options.

Plus, it’s a rare win/win of indulgence and plausible productivity.

https://www.linux-magazine.com/

I wasn’t aware of effects until I read the article, but I like the idea. The example you have is just an interface. Effects work a bit like boundary hooks. A pure function only works on things internal to its scope, and so it has no effects. An impure function might affect things outside of its scope, and may want to allow the caller to hook when those effects occur. Think a function that uses the gpu. That’s a side effect, and the function should be decorated to reflect that.

I’m guessing some languages would allow for checking to ensure that any induced effects are correctly noted and advertised so that the system as a whole can be more easily reasoned about.

Seems like a perfectly cromulent solution.

The J language actually provides a lot of the niceties of the core Q / kdb functionality. It even has Jd, which is an on-disk columnar database. I don’t know if it counts as being commoditized, as the price in terms of time and effort to learn the language is still quite high.

You may want to check out J as a language. It is wonderfully terse and allows for point-free programming, and has all of the advantages you point to above.

I subscribe to both Linux Magazine and Admin Magazine, both at [1]. I found they are more technical than Linux Format, and I’ve often come across things in them that have been useful and wouldn’t have shown up in my normal stream of news.

I would highly recommend them to anyone interested, they’re also surprisingly re-readable.

[1] https://www.linux-magazine.com/

I think the GP was proposing an organic way to expand knowledge. Reading adjacent documentation expands your knowledge of what’s possible. An LLM will tell you how to do a specific thing, but you need to know such a thing is possible before you can effectively ask about it.

In this way, LLMs may passively discourage discovery by providing immediate, specific answers. Sometimes there is value in the journey.

Thank you for the clarification. I didn’t know about the differing mechanism, and you’ve sent me off on a research rabbit hole. Always a happy result of an HN thread. I appreciate your follow up!