skysight-inc/HackerNews huggingface dataset:
Isn't that basically how AWS Lambda operates, using JSON?
This was the issue. Why should a new version make it hard to run old code for no particular reason except to break things.

Folks using u”” were already being careful with Unicode . Supposedly Unicode was important enough for 3 to default to it.

The cost benefit of then destroying code using u”” made no sense to me. It was unnecessary. This was followed by the oh just upgrade thing. I’d love to see the “quick” upgrade guidos employer did. My guess is a total lie that it was easy and it probably took years and VC type money.

It’s not about using new features, it’s about not unnecessarily breaking old or allowing for cross compatibility.
You want to get away from sweeping generalisations because once the build/test/package/deployment tax of a modules approach bites, you do want to go monorepo microservices - it’s free clawback of time wasted building and deploying all the parts of a huge system that you didn’t change in your PR.
A different or future compiler is going to "bitch" about more bugs in your code.

But I see, you're not interested in correcting the bugs you produce. You obviously prefer the "three-monkeys solution" to correctness problems.
I agree (ha!)

If you make everybody happy, you're a politician and you're not being effective in your role. With the caveat that many people don't fully understand their role within an organization. A given person is more likely to have been hired to go with the flow than to provide, say, technical rigor or sanity checks.
The article above, and most if not all the comments I read right before posting this, seem to be very quiet about what I thought was one of the main "distinctive elements" of Microservices.

I.e. the idea that each microservice has direct access to its own, dedicated, maybe duplicated storage schema/instance (or if it needs to know, for example, the country name for ISO code "UK" it is supposed to ... invoke another microservice that will provide the answer for this).

I always worked in pretty boring stuff like managing reservations for cruise ships, or planning production for the next six weeks in an automotive plant.

The idea of having a federation of services/modules constantly cross-calling each other in order to just write "Your cruise departs from Genova (Italy) at 12:15 on May 24th, 2023" is not really a good fit for this kind of problems.

Maybe it is time to accept that not everyone has to work on the next version of Instagram and that Microservices are probably a good strategy... for a not really big subset of the problems we use computers for?
As someone who does not use Python, the end result of this is that I now look into whether random utilities I use happen to be written in Python, and if so try to find an alternative. This is because I felt the pain of this transition -- again, as someone who does not program in Python. It has been miserable every time some random utility starts complaining that Python 3 is missing and then somehow when you install it something else that wants Python 2 starts complaining. You have containers that have worked for years that all of a sudden error out saying "Python 2 is no longer supported," and you have to dig up whatever library or utility that would otherwise work fine has some sort of date-based check or something? I don't know, all I know is a compiled C++ thing works the same yesterday as it does today, and I can upgrade on my timeline, not have a random Docker layer cache invalidation result in a week's worth of Python 3 migration in the least important part of my build. And it keeps happening, again, because this is not in stuff I directly edit, it's all in random dependencies and sub-utilities of utilities I install. So it is non-trivial to even go in with the mindset of "I will update everything on our systems that use Python". Although I guess if it's being pulled completely now that job will once again be done for me. Sigh.

I have this opinion about no other language. I am generally neutral about languages I don't use. But literally my only experience with Python is porting to Python 3. It's like a sitcom scenario of how to force the worst possible first impression for a language ever. The amount of slowdown and pain that Python 3 has generated on our non-Python project is really just out of this world ridiculous.
Yep, I was wondering if this didn't just need a topological sort (as shown by the make solution elsethread).
"being disagreeable-that is, behaving in aggressive, selfish, and manipulative ways" - am I the only one finding this definition incorrect? I think a disagreeable person is one not willing to accept an opinion they find incorrect. None of the attributes they listed seem relevant :) Or maybe I'm just being disagreeable
There is a whole range of programs that fit in between "output a single block string of text" and "yer a compiler, Harry!".

And maybe the right answer is to import a compiler's worth of tooling to output a bit of code. But to me that seems like needless overhead, since meaningful whitespace isn't really a positive to begin with.
I’ve said this before about applying Carmack’s architectural input on this topic:

Games are highly stateful, with a game loop that iterates over the same global in-memory data structure as fast as it can. You have (especially in Carmack era games) a single thread performing all the game state updates in sequence. So shared global state makes a ton of sense and simplifies things.

Most web applications are highly stateless with request-oriented operations that access random pieces of permanently-stored data. You have multiple (usually distributed) threads updating data simultaneously, so shared global state complicates things.

That game devs gravitate towards different patterns for their code than web service devs should not be a surprise.
Why not? If there's one tried and true way to ensure an animal or plant species survives and thrives despite the damage humanity does to the entire ecosystems, it's to make that animal or plant a food for humans.

The most successful land animals today are... cows, pigs and chicken.

(Compare with horses, which were successful because they were useful... until they weren't anymore, and their population dropped. And yes, this also implies that lab-grown meat is an extinction-level threat for aforementioned farm animals.)
Which is the actor model with supervision hierarchy (for clarity). I happen to agree, the actor model is the best approach to writing micro-services in my humble opinion. I would still call them 'micro services' though. Has the term 'micro-services' been overly constrained to RESTful only APIs? If so that would be a shame.
> It's okay to have files with 10,000 lines. It's okay not to put "business logic" in a special place.

Couldn't disagree more. As usual, it's a tradeoff. You could spend an infinite amount of time refactoring already fine programs. But complex code decreases developers productivity by orders of magnitude. Maybe it's not always worth refactoring legacy code, but you're always much better off if your code is modular with good separation of concerns.
I talk about “thinking in public” from a leadership and knowledge sharing perspective within an organization, so this might not be the same angle the OP is considering or asking about. But in a heavily remote world, messaging apps hold the vast majority of our knowledge. It may not be the best model, but it is the dominant one. If the info is there, these apps become powerful knowledge databases for those who know how to use them. If the info is there, company direction and strategy can more easily be understood by a wider audience than just the upper level executives and managers.

I give some specific examples in this blog post I wrote late last year: https://www.polluterofminds.com/thinking-in-public/
>>"headless browser" variant of your app

> Exactly. Do this.

> The app is an object. It has an API. It knows how to coordinate its pieces. The local I/O, the remote I/O, any timing stuff. All of it. Then you plonk the UI on > top of that. You can have sub-parts, but you need one piece that ties it all together, on the model side.

This is exactly what I did with all projects I've worked on. It helped that I had to target both, iOS and macOS where sharing "business logic" was crucial, so you were kinda "forced" to think about that.

To put it simply, there is one question I'm asking myself, can I delete UI and then rewrite it from scratch without updating non UIView/NSView code (just calling MyClasses i.e. my APIs)? Let's just say, if I have to write NSSortDescriptor again, that means there is an architectural issue with my code, which has to be fixed.
I think the big benefit is not the actual split into files, but the coincidental (driven both by features of some languages and also mere programmer convenience) separation of concerns, somewhat limiting the interaction between these different files.

If some grouping of functions or classes is split out in a separate file where the externally used 'interface' is just a fraction of these functions or classes, and the rest are used only internally within the file, then this segmentation makes the system easier to understand.
> It's okay not to put "business logic" in a special place

It's not. This is the thing where you start thinking "YAGNI", yadayada, but you inevitably end up needing it. Layering with at least a service and a database/repositories is a no brainer for any non-toy app considering the benefits it brings.

> It's okay to have files with 10,000 lines

10.000 lines is a LOT. I consider files to become hard to understand at 1.000 lines. I just wc'd the code base I work on, we have like 5 files with more than 1.000 lines and I know all of them (I cringed reading the names), because they're the ones we have the most problems with.
C++ is huge and growing every 3? years (C++17, 20, 23...) is it really possible to master or can you only ever get to the point of being good enough to be dangerous?
Not sure if there are enough lawyers in existence to make it possible. When 100,000,000 say they want to immigrate legally, that level of interest will grid lock any system unless we automate it.
Have you spent any considerable amount of time living in Colombia to feel confident enough to make these type of claims: "not defending them, but in the countryside is common that the guerilla defends the farmers, and the hostages are corrupt politicans."

A close family member of mine was kidnapped in the early 90's and I can assure you that he was neither a politician or a corrupt one at that. First thing he did after paying his ransom was to send his children abroad where they remain to this very day.

Aren't you aware that Colombia has the highest number of internally displaced people in the world at 8 million! Guerrillas aren't solely responsible for this, but the paramilitary groups which are equally responsible emerged as a desperate response to counter their growing power and influence throughout large regions in the country.

Aren't you aware that guerrilla groups such as FARC recruited over 18,000 minors in the countryside against their will. Poor peasant children some as young as 12 forced to take up arms and fight for a cause which long ago lost any credibility among the general public.

Would you mind pointing me to the media that you consume which has allowed you to have such an enlightened perspective which seems to elude those of us living in Colombia?
If the file only contains static methods, it doesn't matter too much. However a class with mutable state should be kept pretty small imo.
And that's why all drugs need to be legalized. ASAP.
So why did for example Ruby not have such a painful transition from 1.8 to 1.9/2.0? My theory is that the Ruby people make the migration in many steps, it started even back in at least Ruby 1.8.6 and they did it with a lot of care on how to make the transition as painless as possible while the Python team just broke everything and bet on that tools like 2to3 would just magically solve it.
> I think a lot of “modern” languages get this right by including these things from the start. The experience is so much better.

I don't know how others did it, but I learned with MS Visual C++ in 1996.

File -> New Project -> press F7 to compile, F5 to debug. That's it. ~30 years ago they got it right. I even remember my Windows CE experience ~15 years ago that allowed to build and debug the entire OS from an IDE.

Now you have to open your command line and write like it's 1985.

Today VS is free (Visual Studio Express?), with analyzers, tests, vcpkg, etc. There is also Qt and other similar tools that I use for embedded like Keil, IAR, Eclipse derivates, etc.

C++ != Makefiles. I don't write Makefiles or fiddle with the build system since... ever?. Except for some AOSP stuff that still uses them or perhaps editing some linker script for embedded.

PS: that said, "experience" is relative. Having to use the command line in general but mostly for learning is terrible.
you scale the component containing your module to multiple nodes, same with microservices, same with monoliths. the only reason it might be hard is if some other module in the component is aggressively preallocating resources even when lightly used, and that is a problem to be solved by itself, orthogonal to the deployment strategy

with a good branching strategy
I want modules that are highly decoupled. But it's often more painful than extracting some API from a monolith and defining a message passing strategy, interfaces, etc.

Another way to put it is that teams that share parts of the same codebase introduce low level bugs that affect each other, and most organizations are clueless about preventing it and in some cases do not even detect it.
Yes — and we’re asking about the case of a quiet conversation in a bar, where someone surreptitiously records using specialize equipment.

I think it’s very telling you made a strawman rather than respond to that point.
This article seems to have missed 16 years of event-based architectures, domain driven design, bound contexts, CQRS, and pretty much every reason we use microservices.
Should be noted the 1970s were marred with economic turmoil and inflation shocks. This would have been essentially just before the 1973 oil crisis.

The United States in general and New York City in particular wasn't doing too hot in the 1970s. I think it's hard to understate quite how bad things were[1].

[1] https://www.youtube.com/watch?v=RQkhD-2cWwY
I'm working on a platform that connects consumer goods companies and independent sales representatives in an "Uberesque" business model.
The video's description of their brain and hunting behavior reminds me of PID controllers—making predictions about where the prey should be, adjusting their head to target it, and using the error in their expectations to update their predictions.
What do you mean by heavyweight? protobufs should be much faster to work with than JSON.
What is a "solver"? Do you have any resources where I can learn about them?
“It's high time people like you stop making up excuses and start to own up their misconceptions, misjudgements, and mistakes.”

What is it about python 3 that brings out this lecture stuff.

I would really like to see the inside of this “easy” change at even the bigger most well resourced places. Google / Facebook / Dropbox etc.

At small places where a program is working and programmer is gone they are not investing in ports.

Anyways - they did eventually get a clue. It’s much easier NOW to handle this, but it wasn’t at the start. Yes, they did put u”” back in. No it did not destroy the world.
Pulling in dependencies in C++ when you come from something like Python or Ruby is the absolute worst. I just recently fought through a big mess of this, the gist of it is ExternalProject[1]

1 https://cmake.org/cmake/help/latest/module/ExternalProject.h...
I often want to have multiple parts of the code open at once. Sometimes 5-10 different parts of the code (usually not so many as that, but it depends what I'm doing) so I can flip between them and compare code or copy and paste. Most editors I've used don't have good support for that within a single file (and having 5 tabs with the same name isn't going to make it very easy to tell which is which).
Yeah, I think this a very much worst case scenario though.

<rant>
You will (for most statements) both be able to find a best and worst case. That's the catch with most generalized statements/ principles, e.g., DRY. The challenge is to find a good "enough" solution because perfection is usually either unfeasibly expensive or impossible (different viewpoints, ...)
</rant>

Though it's kinda hilarious that the source code of a MS project is not natively viewable on a MS platform.
Same, Asphyxia tutorials were considered very good back in the day for democoding in x86 asm. I think they were included in "Programmer's Heaven", a CD full of (obviously) programming guides, tutorials and technical manuals https://archive.org/details/Programmers_Heaven_InfoMagic_Mar...
> and interact with them using their well-defined and correctly-behaving interfaces, you won't need to read the code.

Don't you want determinism and deterministic simultations? If you do, you'll also need stub implementations (mocks, dummies) for your interfaces.

Some notes on that: https://blog.7mind.io/constructive-test-taxonomy.html

> A time may come when you need to separate out services.

Most likely it won't if you organise properly. For example, if each your component is an OSGi module.
Depending on how philosophical you want to get, there'll be people who derive pleasure and purpose from sharing what they know or building something that is enjoyed by others. There'll be people who gain pleasure from being known for being helpful/useful/knowledgeable or even being recognized at all. Even if we can't call it altruism that's not necessarily a bad thing. I guess I just feel that there are, and likely will always be, plenty of incentives for people to create and share online besides financial ones.
The current system does not apply the law equally. While I agree in principle, reality doesn’t match the reported ideal. This isn’t due just to police forces, but also to judges, juries, and the quality of lawyers. The rich, the good looking, and the well spoken have a distinct advantage in the court system. Additionally, most people never have their day in court, they’re instead pressured and intimidated into plea bargaining.
> using features that don't exist in an older version

Except they broke the old way for existing features, required you to use the new way and in most cases you could manually write code so it would still work with both. Meanwhile the only tooling provided by the python 3 crowd screwed over anyone with an existing customer base stuck on python 2, which at least early on should have been a foreseeable problem. Not to forget that anyone stuck on python 2 was literally Satan and projects where outright "shamed" to drop python 2 support.
Use ipython's magic function, %paste. If you need to make minor edits, %cpaste. If you're exploring, consider using a notebook.
Yeah the DNS resolution issue without cgo is quite a hassle.

Luckily this should be solved in 1.20

https://go-review.googlesource.com/c/go/+/446178/
This being the UK, sheep is more likely ?
As a layman, possibly under the distant influence of Jordan Peterson, I thought "disagreeable" meant strong-willed, principled, uncompromising (on what one considers important), direct, etc., i.e. what the article probably designates as "combative"; and was surprised to see "selfish", "manipulative", and "deceitful" also lumped into this category. These seem to be so different personality traits...
To be fair, you're also likely to be missing that if you do join a dance club.

Source: I play for dance clubs as a musician (they usually use recorded music, but will hire a band for an event such as their annual ball).
Ideally, What I want is the ability to decide later whether a particular call should be local, or RPC, and I should not have to care about any of it until I need to start scaling. I should also not need to specify locally what is going on - my reference infrastructure should handle turning the call into a jump-call or a net-call. Ideally, the fiber system that simulates multithreading for me should have an extensibility point that allows my RPC infrastructure to hook into it and "do the right thing" by treating RPC calls as the equivalent of cross-proc co-routines, especially if my OS lets me transparently share memory between two processes: In a way that would let me share pointers and modules across them.

Someday I will find a way to untangle this wishlist enough to turn into a design.
LNG will be a welcome capability for a country weaning itself from a violent authoritarian.

This will not slow the green energy transition because hydrocarbons are still required for almost every technology in existence (including the ability to build PV panels).
> It's absolutely ridiculous, and MasterCard's attempt to destroy girocard by forcing banks to choose one or the other is an obvious cash grab to destroy competition.

I think there’s a similar situation happening in Canada where multiple big banks are adding Visa Debit to their cards (in addition to Interac) and boiling the frog on phasing out the Interac System.
I just manually alternate bedroom/living room throughout the day. Yes, it's a lot of walking (1up1down) but still better than spending ~£50 on each radiator.
I have been using Fly.io for a few projects with Elixir and Phoenix (e.g. [0] )

The main advantage is, that I don't have to worry about hosting and the simplicity of deploying Phoenix applications (I don't know how well Fly.io works with other stacks).

The CLI is dead simple, and as with any other 3rd party services: if it works, you're in heaven - if doesn't you're in hell.

The reason I went with Fly.io was the following:

- It's pretty cheap (e.g. <5$ is free), I have been using it for a few months, and just hit the 5$ limit

- It's easy to migrate to a different service, if Fly gets expensive (again for my elixir / phoenix projects)

- The community support is great!

Some improvements Fly.io could make:

- I had an issue with blocked ports on my side and ended up wasting half a day to figure out why certain commands worked and others didn't. Again this is on my side. The error message could be better than saying: "Error tunnel unavailable: failed probing "personal": context deadline exceeded"

- Once in a while the something is down ([1])

- The billing is not very clear (e.g. split by projects could be useful, then instead getting an overall usage)

[0] https://ogtester.com/

[1] https://status.flyio.net/
But finding and better understanding its value to society is precisely what the funding is needed for.
If you want to scale horizontally then why just run multiple copies of your monolith? That will work just fine unless you're really big, in which case you'll probably be wanted to write your own solution rather than depending on a cloud provider anyway.
> your task is to just make it a little bit faster. Where do you begin

With a trace from a profiler tool, which will tell you which line number is the hot spot. If run from any modern IDE, you can jump to the line with a mouse-click.

In essence, the file boundaries ought not to make any difference to this process.
If GitHub (or whatever you use) says 'sorry we can't display files that are this big', that should be your hard limit...
Why I build Telegram channels?
The Airizer Air Max is an incredible solution for on-the-go vaping, but unfortunately not exactly cheap.
Seems like you're talking about algorithms issues, not code complexity. If your code needs to scale (at all, never mind quadratically) with the size of the data, you're doing something very wrong.
Whoever terminates this http request gets to run arbitrary code on my computer that I haven't read, in the context of my user
I believe there's a guy that attends the THE VINTAGE COMPUTER FESTIVAL MIDWEST that had this working. I saw something like it 2 years ago.