skysight-inc/HackerNews huggingface dataset:
I think we've found in many situations that the microservice boundaries make it easier to change things. We were pretty careful in making fairly conservative choices initially though, and split some of the bigger systems up more over time.
When I started programming, linking was the only way of packaging software in mainstream computing, if it was so superior we wouldn't have moved away from it.
There often is a choice of using a safer solution over raw performance. In C++ for example you can fight C strings, or you can just use std::string, there is no need to always go with the dangerous solution when that piece of code isn't a bottleneck.
Microsoft says SolarWinds hackers stole source code for 3 products
Exactly with this vision I started beginning of 2020 our Go monolithic backend. Currently, one year later with a few people developing it, it's working very well. And thank god I resisted and pushed back against people who were advocating to split off parts into AWS lambdas, misguided by confusing "physical" separation for logic separation.

And regarding the cost you mention, I don't think there is any. Yes, the components only know each other via their interfaces, not their concrete types. Yes, you need to define these interfaces. But that's in essence plain old school dependency injection. You'd do that anyway for testing, right?
They spend more in ads...
ORMs give an affordability to write code faster. That may save time, but instead of saving time, you can also reinvest in better quality and performance. That's up to you and your team.

For instance, Django has prefetch_related and select_related. At almost every Django conference, there's a talk on this topic because it's so important and very underused/overlooked. But these are provided methods of the ORM.

Aside from that, there are wonderful introspection tools such as django-debug-toolbar to view the raw SQL and its performance.

It can be argued that if a solution written in Django hasn't had its database performance introspected with for instance django-debug-toolbar, then the solution isn't done. This is a small step with big rewards.

This introspection can easily identify where raw SQL is useful. But apply it late in process: As a project matures, the costs of converting some queries into raw/hybrid SQL are lower, as the statement is less likely to change. But keep these SQL statements in the models and managers, don't let them spill into views, template tags etc.
I’ve noticed this in other contexts too.

For small queries with straight forward joins, a query builder is nice and readable.

But for larger, more complex queries, I found putting the query into its own file was best for readability.
In my experience, you need both numbers. A customer naturally wants to know when a change arrives in production. I call this "latency", you call it cycle time, but maybe there is a small difference because I also try to include the time it takes to even start development. But a customer also wants to know about effort, often. Because usually effort is what gets billed. So a 10min (realistically, the bill we be about an hour, won't it ;) ) change has a five day latency, which is actually a relatively fast pace for a legacy system with many different stakeholders.
Eh, I suppose it's a matter of opinion, but no, I find it pretty consistently organized and the abstractions are pretty good.

Games are rediculously complex perhaps, and I think UE4 saves you from a lot of it while also giving low level access if you need it. One could call it bloated, but it's bloated like django is bloated, which is to say it has batteries and a lot of other stuff included.
SpaceX Starlink: User terms of service declare Mars as ‘free planet’
How to Manage Your Manager
Come over to Sweden, things are quite dandy here.

Never thought I'd say that in a positive manner though.

Wish you the better and best.
They're not the prettiest sight, yes, but I think anyone who isn't in some way a geek particularly cares about what's actually in URLs.

There's a reason why Apple got away with only showing the hostname of a URL: It doesn't matter to ordinary people. :)
Eh? Are you suggesting this site is for bar owners. You parent and probably everyone else is assuming the perspective of a bar patron.
Oh they certainly can. But they have to compete against huge greenhouse complexes. So basically you are trading logistics vs. economics of scale. I don't know who would win in every case.
In my opinion it will become unusable and unmaintainable faster with microservice spaghetti. With monolith you can get by with bad design longer. But anyways, everything boils down to good structure as you said.
I made a PRORES-lookalike for Windows
Reasons Your Company Needs Application Portfolio Management
Keeping up with a node project is an impossible task, you would have to dedicate one full time developer just for doing upgrades. There are daily updates and a lot of them will just break your code due to the poor testing culture & lack of backward compatibility.
I understand your sentiment but for me the realization is different.

For me seeing the streets of my capital city completely empty at beginning of lockdown, as well as the trams and buses (even though you could ride them), made me realize that I was living in an environment that is fundamentally not pleasant. That it was people that made it alive.

Without people, I saw that this city which I always thought of as "the place where I can do anything, almost any time of the day" is really just a conglomerate of gray buildings, commerce, lots and lots of roads and noisy traffic, and very little green.

The spell was good while it lasted. That said I am also past 45 now... if I was younger I might still want to come back to a big city when I can in order to have access to more activities.
In my main side project what I've done is separate different conceptual components in clojure libraries that I then import into my main program (clojure enables you to seamlessly require a private github repo as a library).

This way you get most of the benefits of separating a codebase (such as testing different things, leaving code that barely works in the repo, pointing to older versions of part of the monolith, smaller repos, etc.) whilst integration between modules is a one-liner, so I don´t need microservices, servers, information transformation, etc.

There's even the possibility to dynamically add library requirements with add-lib, an experimental tools.deps functionality.
Zuckerberg's Big Problem Has Been Obvious for 17 Years, but Nobody Will Admit It
dos2unix / unix2dos is often preinstalled and works as well
I don't think it's "the rotation of the wheel", but rather the kinetic energy of the rider. The wheel just drives the pump.
some people are always offended. no matter what.
i think its a funny wordplay.

but seriously. if OP wants to already prevent sjw outcry: change the name
Weird, we do it with Python all the time. Just don't use globals/threadlocals everywhere and you will be good.
No it’s the same for me.

On mobile, the play/pause buttons work but the sliders don’t do anything.
Is this talking about a specific incident of someone being "cancelled"?
I struggle to think of who has actually been a victim of this.
You wouldn't need to use it on videos you produce if you don't want.
Yet the cost per head in the US of Medicare is higher than the UK’s health system.

That’s kot cost per head covered. That’s dividing government health spending by the US population.

The US pays enough in taxes to provide great healthcare to every citizen. It chooses not to.
If I recall correctly (it's been a while) a good way is to use Ada fixed-length strings wherever you can, and use something like Dmitry Kazakov's UTF-8 library in other places. People often use unbounded strings in places they don't need to instead of declaring a fixed-length string when it's needed.

Nice to see somebody's still using Ada. I gave up on it for new projects because of the lack of infrastructure and 3rd party libraries. It seems that half of comp.lang.ada consists of professionals from the aerospace and embedded systems industry and the other half are crackpots who want to create a Caesar cipher plus spam. It always looked like a weird community to me (but that has indirectly to do with how Adacore conduct their business).
PathTracedPong – a real-time path traced game for desktop and mobile using WebGL
Error handling has been wrong since the beginning, and has continued to be wrong ever since.

First, we had error codes. Except these were wrong because people forget all the time to check them.

Then we had exceptions, which solved the problem of people forgetting to check by crashing the app.

Then the Java team got the bright idea to have checked exceptions, which at first helped to mitigate crashes from uncaught exception, but caused an explosion in thrown exception signatures, culminating in "catch Throwable". Back to square one.

Then we got multi-return error objects, maybes, panics, and all sorts of bright ideas that fail to understand the basic premises of errors:

Any error system that relies upon developer discipline will fail because errors will be missed.

Any error system that handles all errors the same way will fail because there are some errors we can ignore, and some errors we must not ignore. And what's ignorable/retriable to one project is not ignorable/retriable to another.

Attempting to get the complete set of error types that any given call may raise is a fool's errand because of the halting problem it eventually invokes. Forcing people to provide such a list results in the Java problem for the same reason.

It's a hard problem, which is why no one has solved it yet.
As long as you're not using any libraries/frameworks that use them.
> The loan is taken from a government agency, that means non-profit. The current interests rate for student debt in Sweden is 0.05%. This is surely a major difference from the US?

Interest rates in the US are higher, but unlike Sweden your repayment is based on income. If you make less money, your monthly payment will be much less, and the debt will be forgiven after 20 years.
Yes the political gains of making sure that we are a little less worse off in the future.
Is it really an immensely complex calculation? I worked with GIS for maps, fleet tracking, route optimisation, logistics and so on for quite a number of years. Yes, the traveling salesman problem is NP-hard and not completely solvable with current computation but... Approximations of it are actually quite feasible, and have been since way before I worked with GIS in 2005 as the platform we vendored had these features since late 90s, early 2000s.

I can completely understand that the algorithm for driver selection/matching and calculations of possible different routes for those drivers between them and possible passengers can be quite complex, it also sounds a bit into the realm of the knapsack problem (weighing in all the different passengers and drivers to given an optimal set of matches) but I don't see necessarily how the route calculation/prediction with distance would be an immensely complex one.

And I'm completely open to gain more knowledge in this area to understand it and prove my naive assumptions of the problem domain wrong, feel free to shoot me down.
It is easier to isolate business logic with a microservice architecture, but as the microservice graph gets more complicated so too does administering it.

How do you make graphs that make sense of your various microservices? How do you make sure code doesn't get stale/all versions are compatible/rolling back code doesn't take out your website? How do you do capacity planning? How are service specific configurations done? How does service discovery work? How do you troubleshoot these systems? How do you document these systems? How do you onboard new people to these systems? What about setting up integration testing? Build systems? Repositories? Oncall? What happens when a single dev spins up a microservice and they quit? What happens when a new dev wants to create a new service in the latest greatest language? What happens when you want to share a piece of business logic of some sort? What about creating canaries for all these services? What about artifact management/versioning?

What about when your microservice becomes monolithic?

Complexity is complexity no matter where it exists. Microservices are an exchange of one complexity for another. Building modular software is a reduction of complexity. A microservice that has business logic mixed with server logic is still going to suffer from being brittle.
I've found Local History on these JetBrains IDEs to be really helpful too. Particularly when combined with "Put Label" command (which I assign to a keyboard shortcut). This lets you insert a descriptive label info the stream of your local history snapshots (such as before you attempt something), so you can go straight to one of those labels and diff against current. Useful when you're trying out an approach with parts that may be discarded, as it's handy for reverting lines of current or overwriting and inserting blocks back from the snapshots. You automatically get a label after certain events, like a test fail or VCS commit. I think there's a snapshot after every save too, and you can configure autosave to happen whenever the editor pane loses focus of you want to.

The only things to watch out for with local history in these IDEs is that the snapshots are deleted after five days by default, and all are wiped if you need to delete your IDE cache for any reason.
If writing text more than 4 hours / day is what you do for a living, and you have at least 10 more years left of doing that, not learning Vim is just lazy. Vim gives you back enough time to think about what you're writing.

Also, if you go cold turkey, you'll be productive in less than a month, and arrive at a good workflow that fits you in less than six months, flow that you will improve over the years in amazing ways.
This isn't how residential pricing works. End residential customers typically don't pay these increases
Error handling in Rust is the most appealing feature for me. Not performance. I really can not understand people who want to ignore error cases or write their code pretending that error will never happen. All of these "unwrap", "expect" sounds to me like "ok, there might be an error but I'm too lazy to write code to handle it so let's just hope it will never happen”.

Of course, when your code is full of “panic”s, then errors handling will be a mess, but it just means your code is a mess and you need to finally take care of the errors. ‘Result’ and ‘enum’ are the best friends in this.

By writing the code to handle errors you’ll find that many of them are recoverable; that some errors might look “critical” for one function and “insignificant” for another, so if you will not panic and just return this error, at some point of the path it will be recovered.

This post mentions some useful libraries for simplifying the errors tracing (with contexts), but the tone is too sarcastic, sounds close to hysterical.
This is the never ending cycle of "too much order" - "too much chaos". It takes a lot of experience to be able to judge how much chaos you want. That is all.. experience. I don't think any theoretical theory can tell you how much or how little is right
It's a means to shift the problem to Someone Else; I've got my codebase, it is mine and it is perfect. Integrating with it is someone else's problem.
Team Communication: Reduce Round Trips
If you don't mind telling this story, why did you end up merging them back in? I would have thought that needlessly making microservices is bad but not bad enough to justify merging back.
The primary advantage of proper pattern matching compared to ad hoc "instanceof" checks is exhaustiveness checking. I love the comfort in knowing the compiler will tell me all the places in the code that need to be updated when I add a new case to an algebraic data type. I know the article touches on this, but IMHO the author under-appreciates this important feature.
Yeah, it is tricky. Perhaps if the prompt was generated async?

Turns out my main issue was due to having a slow node --version command due to using asdf!

This project was a huge help: https://github.com/danhper/asdf-exec
Absolutely. games need to be consumeable in a meaningful timespan. Complexity gets in the way. Do we really want a second life? Nothing beats reality.
Thanks for bringing up comb. explosion. I think its also a huge thing with autonomous driving...
What service in their right mind would link to any content that requires payment? Do media organisation think their content is so great that people will pay just to link to it? Links drive SEO, charging for them is the equivalent of shooting yourself in the foot.

This can only work if governments force companies to display selected media links and then charge them for it. It can only work if governments force search engines to alter their algorithms to preference media organisations and charge the search engine in the process.

It is the worst piece of tech related legislation conceived in a so called democratic country, the fact that its even progressed to this stage is mind boggling.
Gaming needs the same cards, but they are not running at max 24/7.
“Secured the means to reproduction”, sure does sound like something an alien, trying to act human, would say about finding a partner.

A lot of people, especially in pub cultures like the UK socialise at their locals, they don’t just go there to aggressively pursue sex with strangers. It’s where they meet their friends after work, where they go to watch sport on the weekend etc.
I worked on a project that was a monolith. A team was placed to rewrite it to microservices and shortly after I quit that job. About a year after that I ate lunch with a ex-colleague that told me they were still working on that rewrite.

Looking at the page now it looks like the monolith is still running as far as I can see, about 5 years later. I guess they gave up. :)
I'm a big Falcon user as well. Got into it because it was easier to get up and running without bells and whistles vs the more "popular" frameworks.
Here is the thing, whatever you write doesn't work without linking, so no we never moved away from it.
https://www.crea-biz.com/
The slightly weird thing for me is that I'm bored but I'm also silently nonplussed about quite a few social venues being shut because I simultaneously don't really enjoy but also get FOMO over (say) nightclubs - I'm sort of doomed to be perpetually normal enough to talk to but odd enough to weird people out.

Basically one less thing to be neurotic about, although the fact that of my two real friends one is hard to talk to because of a subtle cultural difference and the other clearly only tolerates and has clearly reached the stage where a friendship bifurcates and people trying to hurt each other suddenly, has been cruelly exposed to me.
One third of the CO2 in the atmosphere is man made. It's not small. 66% times 1.5 is 100% meaning humans have added 50% CO2 on top of natural CO2 in the atmosphere.
> It's a hard problem, which is why no one has solved it yet.

The way you described it seems not so much as hard problem. More like an impossible one.

That said. Perhaps error handling isn't one problem at all, but several problems masquerading as one. In which case Rust approach makes much more sense.
As an outsider what’s the order of magnitude on humans that have this setup currently functional? 100? 1,000? Etc.
I don't have a source for that, but I've always thought that low tire pressure doesn't really contribute that much compared to aerodynamic drag, even on the joyride home at 20 km/h on a heavier freeride rig.
I think the key point of Fowler’s article, which is obscured a little by all the monolith discussions, is that try to start with microservices doesn’t work. He’s claiming this from an empirical point of view -- if you look at successful, working systems, they may use microservices now but they most often started as monoliths.

People are talking about Conway’s law, but the more important one here is Gall’s law: “A complex system that works is invariably found to have evolved from a simple system that worked.”
Data that airbnb owns values much more than their website stuff. And you need tech people in ML and data areas to manage and use these data effectively.
The talent pool is probably smaller, but passionate. It's many people's dream to write Haskell (or other FP) for a living, myself included.

If I may shill, if anyone is hiring for Haskell or FP roles, please let me know.
When I see comments like this it reminds me just how different I am to many people. It feels like I'm an alien trying to understand a new civilisation.

I used to have "sex" and the like, but it was only to experience certain transmitters firing in my brain. Now that I've discovered my right hand I don't have to force myself through that hell any more. Comments like this suggest there is something attractive about such acts even if you take the pleasurable transmitters away. I'm so happy, happier than I've ever been, that I don't have to interact with another human ever again.
for exploratory coding you can also just unwrap, assert, panic..
It's useful to remember that error handling is optional in those cases :)
> The Microsoft syntax is very Microsoft. It involves many leading underscores and long keywords.

Not at all, Microsoft follows the ISO C guidelines to add new keywords to the language.

Which is why you have stuff like _Generic, _Atomic,....
For the mostpart, Rust error handling is okay.
What really rustles my jimmies, however, is the often mandatory indentation because of a lack of an inverse "if let". I prefer to bail out of a block if a condition is NOT met, rather than execute another nested block if it IS met. Rust makes that harder than it should be. It's good code hygiene in every other language, and Rust makes it painful in places. I've even been stopped from doing this by literal bugs in the borrow checker.
We have wind and solar making even faster gains, and being real, right now as well.
Apologize didn’t see it. Thank you.

The request for a textbook, or similar caliber academic content on the question was serious and not intended to be inflammatory.

Particularly, on something new, the ratio of words spent versus insight is perhaps lower up front as the issue unfolds until learnings crystallize. IMHO.
But it would be interesting to those of us that build web pages why this one works this way.

This is not just bad formatting, it’s a deeper mystery.
Healthily / London, UK / Full time, perm roles, remote OK / https://www.livehealthily.com/

Healthily is a self care app with a mission to help 1 billion people "Find their health". We have big plans for 2021 and are looking for some great people to join us on that journey. These are our open roles:

DevOps Engineer https://apply.workable.com/livehealthily/j/0D82F379AD/

Senior Full stack engineer
https://apply.workable.com/livehealthily/j/7BFDD7E44D/

Data Science & AI engineering Manager
https://livehealthily.workable.com/backend/jobs/1352263/edit

We've got a great diverse team of smart, interesting and highly motivated people. You can work from home or come to our central London office - it's up to you.

Don't forget to mention where you saw this ad! We'd love to hear from you.
You are reading something into my comment that wasn't there in order to pick a boring fight. There is of course no such thing as no accent a priori, but there is such a thing as "accents understood by (vastly) more people" and "accents closer to the mean accent of native speakers". When I learn Russian, my English accent is not on the same footing as a Muscovite's; the intended notion of "de-accenting" the English accent on my Russian is obvious.

Consider responding to the substance of the comment instead.
You're not precise though. Precise ought not mean "It is possible to express precise thought regarding memory, yada yada, in this language", it ought mean "A person is capable of expressing precise thought regarding [...] in this language, without making mistakes".