fizlebit

How is it going to work for corporate customers. What if one us employee writes claude output into a ticket, can that be read by a non us citizen employee? What about paraphrased?

The big bet here is that anthropic stays ahead of the curve and is the goto tool for businesses. The risk is disruption to that leader position, or that it can't sell all those tokens because the value/cost ratio is too lower for consumers of them. I suspect that disruption is the bigger risk because the tokens in my experience are valuable, so as they innovate we're betting the value of the tokens goes up and the cost comes down.

I'd like write program / run program / debug program to be as easy as it is in roblox. It isn't that easy though, the set of things you need to do it well is extensive. I wouldn't be averse to a new platform, one in which all io is over highly performant queues, but the moras of existing software tied to unix is large, just look at compilers and all the child processes they launch. It was always shims and it will always be shims.

Scrolling through those images it just feels like intellectual theft on a massive scale. The only place I think you're going to get genuinely new ideas is from humans. Whether those humans use AI or not I don't care, but the repetitive slop of AI copying the creative output of humans I don't find that interesting. Call me a curmudgeon. I guess humans also create a lot of derivative slop even without AI assistance. If this leads somehow to nicer looking user interfaces and architecture maybe that is good thing. There are a lot of ugly websites, buildings and products.

I think if your university doesn't do in person exams with pen and paper then the degrees it hands out are not much evidence of anything.

If you're not interested in learning the course content, then what are you doing there? Pretty expensive waste of time.

I very fondly recall many of the course I did at university. The exams were a helpful motivating factor even for the interesting courses.

Even with anyhow there is a lot of boilerplate it seems to me dealing with crates that don’t use it. I haven’t tried snafu but its name does not inspire confidence.

Clanker (ai assistant) also love to unwrap and if you don’t catch them you have an abort waiting for you.

I do feel like better application sandboxing is needed but so much open source software is built on the Unix abstraction meaning you have to run in a container, but macOS doesn’t have containers as far as I can see, and containers themselves are a bit of a poor abstraction, although maybe the best we can do with Unix at the core. I think something closer to Roblox studio would be cool where when you open an environment stuff just spins up in the background, but there is a good debugger, logging, developer ide, good rendering, eg 3d graphics, separate projects are separate, and when you spin down a game (read app or project) everything spins down.

Looks a bit like Rust. My peeve with Rust is that it makes error handling too much donkey work. In a large class of programs you just care that something failed and you want a good description of that thing:

  context("Loading configuration from {file}")

Failed: Loading configuration from .config because: couldn't open file .config because: file .config does not exist.

It shouldn't be harder than a context command in functions. But somehow Rust conspires to require all this error type conversion and question marks. It it is all just a big uncomfortable donkey game, especially when you have nested closures forced to return errors of a specific type.

I think that vibe coding now with anthropic tools and the latest model means that the cost of writing integration tests is significantly reduced. When the company ships a large product that has components from many teams, there is still a role for QA engineers who run nightly tests and chase teams to help diagnose the issue when there is an issue found. If you don't have such a central team publishing golden versions, then everybody is chasing the same bug. Ideally the integration tests are part of the change acceptance flow, but low frequency bugs (occur maybe 1 in 100 test runs) can still sneak through.

yeah but machines don't produce horseshit, or do they? (said in the style of Vsauce)

It looks from the public writeup that the thing programming the DNS servers didn't acquire a lease on the server to prevent concurrent access to the same record set. I'd love to see the internal details on that COE.

I think when there is an extended outage it exposes the shortcuts. If you have 100 systems, and one or two can't start fast from zero, and they're required to get back to running smoothly, well you're going to have a longer outage. How would you deal with that, you'd uniformly across your teams subject them to start from zero testing. I suspect though that many teams are staring down a scaling bottleneck, or at least were for much of Amazon's life and so scaling issues (how do we handle 10x usage growth in the next year and half, which are the soft spots that will break) trump cold start testing. Then you get a cold start event with that last one being 5 years ago and 1 or 2 out of your 100 teams falls over and it takes multiple hours all hands on deck to get it to start.

I actually prefer a game where the rules mostly come from the DM. I think it is better if there is no players handbook. The characters develop along their story arc, e.g. at some point you character acquires new powers, e.g. your character has been spending a lot of time developing new combat moves, they kind of level up and now the DM explains a new mechanic. Your character has become adept at disarming opponents and now gets such and such a bonus to attempt a disarm.

This is a lot to place on the DM, but I like the anarchy of a system like dungeon crawler classic. You expect some of your characters to die, e.g. in one adventure my character in a last ditch effort to save himself drank a potion of unknown origin, that potion turned him into a mithral statue. It was a fitting end to his short but eventful life.

Another character played by a different player managed through a long process involving books and negociations with his patron to construct a demonic sentient flying dog through whom he could cast spells and see.

This kind of exploration I think encourages players to see their characters much more as characters than machines to be min maxed and it is way more fun.

Give the DM total control to decide the dice roles that determine the outcome of the shenanigans. You try to hire an army of peasants you're going to be dealing with appointing sergeants, logistics, mutany, desertion all before you try to line them up to throw a ladder at some dude, which in the end is probably like a 1d20 >= ac for a chance of 1d4 damage, with of course crit tables, where on a critical success the dude might be tangled up in the ladder and fall over or something.

People say don't reinvent the wheel usually in a business context because writing from scratch is usually a lot more work than using existing technologies. Sure reusing technologies is also a lot more work than you would expect because most things suck (to different degrees), but so will your newly minted wheel. Only after a lot of hard lessons will it suck less, if at all.

That said there are also contexts in which the existing system that was built sucks so bad that rewriting it usually a boon, even if the new wheel sucks, it sucks less from the start.

You at a minimum should engage with the existing wheels and their users to find the ways in which they do and don't work.

In your own time I think it is great to tinker, pull apart, assemble your own things. Every Jedi makes her own light saber right?

Me no like inconsistent use of spaces.

            x += labelW+20;
            hDescEdit = createModernEdit(hwnd, x, y, editW, btnH, ID_DESC_EDIT);
            x += editW + gap;

Am I alone in thinking that all the stuff I get for free (in exchange for some amount of targeted advertising) from Google is pretty cool and that these attempts to break up big tech are going to be very bad for consumers and the economy and is just punishing successful companies that produce products that customers want to use. You all can use mosaic/edge if you want to.

Games are much easier than real work and provide more consistent dopamine hits with their graphics, sound effects and feeling of progression. Factorio while fun is a long way from real work.

There seem to be a bunch of folks for whom shaking the legs is an important part of the process. Can be a bit distracting to others in a team workspace. It makes me wonder whether they should have bicycle desks.

Yeah I'm the same. I can visualize my house. When debugging and there are large number of numbers in systems to keep track of then arranging the systems on a piece of paper just to quickly find the numbers associated with each system helps, but beyond that when thinking about code it is all maths with no spacial or visual component, just logical statements and reasoning. E.g. When I think of a shuffle-shard I don't visualize the sets, I just think, subsets of size k.

It is bad if you print from a Linux laptop that uses WiFi isn’t it?

I can't help but wonder whether the major problem is actually API changing from version to version of software and keeping everything compatible.

If the build language is LUA, doesn't it support top level variables. It probably just takes a few folks manipulating top level variables before the build steps and build logic is no longer hermetic, but instead plagued by side effects.

I think you need to build inside very effective sandboxes to stop build side effects and then you need your sandboxes to be very fast.

Anyway, nice to see attempts at more innovation in the build space.

I imagine a kind of merging between build systems, deployment systems, and running systems. Somehow a manageable sea of distributed processes running on a distributed operating system. I suspect Alan Kay thought that smalltalk might evolve in that direction, but there are many things to solve including billing, security, and somehow making the sea of objects comprehensible. It has the hope of everything being data driven, aka structured, schemad, versions, json like data rather than the horrendous mess that is unix configuration files and system information.

There was an interested talk on Developer Voice perhaps related to a merger of Ocaml and Erlang that moved a little in that direction.

From the Linux conference video I watched I think they have the wrong approach. They’re trying to improve a bad api by adding types do describe it’s awkward behavior. The C programmers who love the Linux style want to be able to change semantics or api without modifying rust code. The solution is straight forward, build an adapter later in C that has well describable and clean semantics. Since it is C and in the kernel and has clear semantics the C programmers can maintain it without having to look at Rust. Perhaps the general lack of encapsulation and layers in the kernel will defeat them as they will need a lot of adapter layers. But for file systems it might be achievable.

https://youtu.be/kQcIV5389Ps?si=9Lixq3OUYxaei7s4

It is a fail/succeed mindset rather than a play mindset I imagine. I definitely feel a difference between a chore and a game. That said not all chores are easily turned into games. But seeking games over chores probably leads to a happier time.

Any chance of a window manager that lets you alt tab between windows instead of between applications. So Alt-tab-tab-tab takes you 3 windows ago, not 3 applications ago, or worse 1 application ago and 2 unrelated windows of that application?

Man I really mis application menus being at the top of windows and being able to layer different windows from different applications in any order that I wish. VNC screen connections just make it into an even worse jumble.

When is the government going to realize that software and business process patents are bullshit and that they should be wholesale dismantled.

I suspect the same should be true for mechanical, civil, and chemical engineering. Eg TSMC doesn’t need patent protection, they can just be the very best manufacturer of chips.

:) yes. I saw that error and wondered whether someone would point it out. I think the author fails to acknowledge that the use of variables like "verb" just make the code much harder to understand than a string that reads mostly like English.

  question = "Is";
  object = "this";
  adjective = "easy";
  String.format("%s %s %s");

  String.format("Is this easy");

Seems like someone should write a book called "Clean Code Done Right" that has actual good examples of code. Maybe Rich Hickey? The high level advice is good, code should be written as simply as it can be. Functions should have a small clear mission and it should be easy to argue that the function is correct locally. That is to say: a functions correctness shouldn't depend in a complicated way on other functions, just a reasonable expectation on the behavior of the functions it calls, and a reasonable simple description of its mission. Easy to state this objective often difficult to achieve in practice.

Maybe a book showing elegantly coded solutions to actually difficult programming problems would be good, e.g. a system with maybe the complexity of high performance sharded fault tolerant Redis. There would be a lot of interesting topics there.

I think people already knew how to write good quality code even in the 80s, e.g. https://www.amazon.com/Large-Scale-Software-Design-John-Lako...

The post is right in that the example code is terrible, Uncle Bob's changes make it much worse, but also the suggested fix is also bad. I think this is better, but the whole thing is silly. Obviously you'd want to write a comment for the function that explains its weird behaviour.

  String getCandidateCountString(char candidate, int count) {
    if (count == 0 ) {
      return String.format("There are no %ss", candidate);
    } else if (count == 1) {
      return String.format("There is 1 %ss", candidate);
    } else {
      return String.format("There are %s %ss", count, candidate);
    }
  }

How many other classes of such bugs exist. Without a public COE one can't know that it was systemically fixed. One can't know whether security boundaries were by-passed by the bug. One can't know what sorts of extra protections are introduced for this type of systemic error. So what confidence would you have in the product with no public explanation -- are you saying, oh they're google, I'm sure they're doing the right thing.

Somewhere in Australia (with Australian accents):

"Hey terraform just output a wall of text, it wants to know whether or not to proceed."

"That's what it does mate. Let it do its thing, she'll be right."