#software of architecture

[nitor-infotech]

Explore the game-changing world of Micro frontend architectures with Angular in this insightful blog. Uncover how these architectures revolutionize web development by breaking complex applications into modular components, enhancing scalability and agility. Further, discover the practical strategies for implementing and optimizing micro frontends for your teams to deploy independently and innovate faster.

So, whether diving into micro frontends for the first time or looking to refine your approach, this blog will ensure you're equipped to build robust web solutions. 

[misuse-oh]

[makkon]

recent stuff in Quake. custom textures, geo, skyboxes

[ahmedtalatene]

It was our house that was completely bombed. We are now in the displacement camps. We go to the sea to wash our clothes due to the lack of water in the camps, and my wife is pregnant. She now suffers from hepatitis caused by pollution in Gaza. Can you help them get out of Gaza before their child is born? . Her only dream now is for her baby to be fine, and for her not to give birth in a tent without medical care.

[ekinoksin]

palazzo medici riccardi

[part2]

[technicallyclassyperfection]

[brasiliangp]

@f1blrcreatorsfest: hards - vintage (bauhaus) inspired 'A house is a machine for living in'

insp. / insp.

[obsessedbyneon]

PC-CADD, 1988

Scan

[blubberquark]

When "Clean" Code is Hard to Read

Never mind that "clean" code can be slow.

Off the top of my head, I could give you several examples of software projects that were deliberately designed to be didactic examples for beginners, but are unreasonably hard to read and difficult to understand, especially for beginners.

Some projects are like that because they are the equivalent of GNU Hello World: They are using all the bells and whistles and and best practices and design patterns and architecture and software development ceremony to demonstrate how to software engineering is supposed to work in the big leagues. There is a lot of validity to that idea. Not every project needs microservices, load balancing, RDBMS and a worker queue, but a project that does need all those things might not be a good "hello, world" example. Not every project needs continuous integration, acceptance testing, unit tests, integration tests, code reviews, an official branching and merging procedure document, and test coverage metrics. Some projects can just be two people who collaborate via git and push to master, with one shell script to run the tests and one shell script to build or deploy the application.

So what about those other projects that aren't like GNU Hello World?

There are projects out there that go out of their way to make the code simple and well-factored to be easier for beginners to grasp, and they fail spectacularly. Instead of having a main() that reads input, does things, and prints the result, these projects define an object-oriented framework. The main file loads the framework, the framework calls the CLI argument parser, which then calls the interactive input reader, which then calls the business logic. All this complexity happens in the name of writing short, easy to understand functions and classes.

None of those things - the parser, the interactive part, the calculation - are in the same file, module, or even directory. They are all strewn about in a large directory hierarchy, and if you don't have an IDE configured to go to the definition of a class with a shortcut, you'll have trouble figuring out what is happening, how, and where.

The smaller you make your functions, the less they do individually. They can still do the same amount of work, but in more places. The smaller you make your classes, the more is-a and as-a relationships you have between classes and objects. The result is not Spaghetti Code, but Ravioli Code: Little enclosed bits floating in sauce, with no obvious connections.

Ravioli Code makes it hard to see what the code actually does, how it does it, and where is does stuff. This is a general problem with code documentation: Do you just document what a function does, do you document how it works, does the documentation include what it should and shouldn't be used for and how to use it? The "how it works" part should be easy to figure out by reading the code, but the more you split up things that don't need splitting up - sometimes over multiple files - the harder you make it to understand what the code actually does just by looking at it.

To put it succinctly: Information hiding and encapsulation can obscure control flow and make it harder to find out how things work.

This is not just a problem for beginner programmers. It's an invisible problem for existing developers and a barrier to entry for new developers, because the existing developers wrote the code and know where everything is. The existing developers also have knowledge about what kinds of types, subclasses, or just special cases exist, might be added in the future, or are out of scope. If there is a limited and known number of cases for a code base to handle, and no plan for downstream users to extend the functionality, then the downside to a "switch" statement is limited, and the upside is the ability to make changes that affect all special cases without the risk of missing a subclass that is hiding somewhere in the code base.

Up until now, I have focused on OOP foundations like polymorphism/encapsulation/inheritance and principles like the single responsibility principle and separation of concerns, mainly because that video by Casey Muratori on the performance cost of "Clean Code" and OOP focused on those. I think these problems can occur in the large just as they do in the small, in distributed software architectures, overly abstract types in functional programming, dependency injection, inversion of control, the model/view/controller pattern, client/server architectures, and similar abstractions.

It's not always just performance or readability/discoverability that suffer from certain abstractions and architectural patterns. Adding indirections or extracting certain functions into micro-services can also hamper debugging and error handling. If everything is polymorphic, then everything must either raise and handle the same exceptions, or failure conditions must be dealt with where they arise, and not raised. If an application is consists of a part written in a high-level interpreted language like Python, a library written in Rust, and a bunch of external utility programs that are run as child processes, the developer needs to figure out which process to attach the debugger to, and which debugger to attach. And then, the developer must manually step through a method called something like FrameWorkManager.orchestrate_objects() thirty times.

[newslettertechera]

The most awaited article of the year is here ... Evolution of automation is all yours now !!!

[321arka]

Creating realistic terrain and topographic models is essential for architects, landscape designers, and urban planners. SketchUp, a popular 3D modeling software, offers powerful tools for this purpose. One of the most effective tool sets in SketchUp for terrain modeling is the Sandbox tools.

Introduction to Sandbox Tools

The Sandbox tools in SketchUp are designed specifically for creating and modifying terrain. They are part of the SketchUp Pro suite and include several functions that allow users to create, edit, and refine terrain models with ease. The primary tools within the Sandbox set include:

a. From Contours: This tool generates a terrain surface from a series of contour lines. b. Sandbox Tools: A collection of tools for creating and manipulating terrain surfaces. c. Drape: This tool projects lines or shapes onto a terrain surface, useful for roads and pathways. d. Stamp: This tool creates flat areas on a terrain model, ideal for building pads or parking lots. e. Smoove: This tool smooths and manipulates terrain surfaces, allowing for more organic shapes.

Read more

[sublimepizzastarfish]

Pirate Software's "rearchitecture" for Stop Killing Games

There's been a lot of fascinating drama around Stop Killing Games. Go read the initiative here:

It is a good initiative, and anyone who is a consumer that can, should absolutely go support it.

Jason "Thor" Hall, CEO of Pirate Software, recently had a few, let's say, "takes" on the matter (I'm trying and failing to remain neutral), which began on a stream. The stream's VOD has since deleted on his YouTube channel.

Louis Rossmann, who you might know as the largest Right to Repair activist in the US, made a response to a section of the releevant stream here:

Thor, CEO of Pirate Software, made two videos to clarify his points:

There is an argument in the video at the 2:08 mark that I will reference later.

(I recommend watching all these videos on 2x speed. You will get the same info out of them all, because especially video 2 is a lot of repetition)

Now, as mentioned above, there is one particular technical argument that bugs me about what Thor, CEO of Pirate Software, is making. Here is the full quote:

How would you keep League of Legends in a functional, playable state? You'd have to rearchitect the entire game. The game is what is called "client-server". So, in client-server models, there's a server, there's a client, and all of the math, all of the game, everything happens on the server. The client just displays it. And the reason we want to do it that way is so that you can't teleport around and do a billion damage. You don't trust the client. You trust the server. The client just displays what it's told. Right? So, if we wanted to rearchitect this, we would have to take all of that server logic, push it back out into the client, and somehow make that playable in a multiplayer-only video game. That doesn't make sense to me. So this doesn't work for all games. Why is [the initiative] calling out all games?

So, first off, yes, most games do client-server architecture for multiplayer logic, because you do trust the servers. It is an important step to curbing an entire class of cheats. It doesn't necessarily mean the client isn't malicious (for example, there are cheats for League of Legends that show a growing circle when an enemy leaves the fog of war in the minimap). However, it does mean the client doesn't know 100% of the game at any time when information is selectively fed to each client based on something like the fog of war. That's awesome.

Some games, like PlanetSide (rest in peace) and Overwatch (2) use what's called client-side hit detection. Some games, like Halo 1, employ more selective hit detection models, where only certain weapons use client-side hit detection (see https://c20.reclaimers.net/h1/engine/netcode/). Client-side versus server-side hit detection can change the overall feel of a game, and it's one of the things game developers decide on in multiplayer-only games that require it. In the case of an massively multiplayer online first person shooter (MMOFPS) like PlanetSide (2), the server simply can't calculate thousands of people's math in a reasonable amount of time, because otherwise the hit detection would otherwise feel very crappy to play, and so the math is offloaded to the client and the client says "hit" when they hit.

However, there are a few counterexamples to the specific technical argument that keeping the game playable after end-of-lifing it requires rearchitecting:

Games with dedicated servers exist - Command & Conquer: Renegade, Starsiege: TRIBES

Games where one client also hosts the multiplayer server exist - Half Life 2, Warhammer 40k: Space Marine

Private server hosting exists - World of Warcraft

Some of these games, particularly the examples with dedicated servers that can be run on user hardware, can also run as the second example.

To say keeping a multiplayer-only online game requires rearchitecting a game like League of Legends means a lack of imagination. More relevantly, it means a lack of systems thinking.

To me, it is very strange for someone such as Thor, CEO of Pirate Software, who is self-described as being a 20 year veteran of the games industry to say. I won't say skill issue, because I think there is an ulterior motive at play.

Just to hammer the point home, I drew up some crappy diagrams in Inkscape because this extremely wrong technical argument bugged me so, so much.

Here is what a client-server model looks like:

Here, you have 10 clients, each being a player of the game. Then, you have the server, run by Riot, the developer and maintainer of League of Legends.

Here is the imagination of Thor, CEO of Pirate Software, had to say on the matter on the required way rearchitect it:

Those who know their network models would understand this looks very much like a mesh network, or a peer-to-peer model. And, to be fair, some games might attempt it.

However, this isn't *usually* how games described using a peer-to-peer (P2P) model work. Most peer-to-peer models, like the architecture used in Space Marines, are often used for matchmaking. Once you are in a game, one of the clients also serves as the host (selecting by some algorithm, like randomly or whoever has the best hardware).

P2P is nice, because the company doesn't have to run servers for matchmaking at all during their lifespan (and sometimes a matchmaking server might be spun up to serve as a relay to help with network issues or help other clients find clients quickly). As we'll get into later, a client machine will also serve as the host machine. It is a perfectly fair and valid, although it comes with it's frustrations (mainly in the realm of network address translation (NAT) traversal, because your computer behind a router is not usually exposed to the wider Internet, though sometimes routers have universal plug-and-play (UPnP) set up, which makes NAT traversal much easier here).

If you've ever seen a message in the game "migrating host" because the host left, they likely use P2P matchmaking, but still use a client-server model. They can just migrate the game data to a new host using the data on the other clients as a seed for the data.

This is likely their setup for actual gameplay:

One of the clients now has a server on the same machine. Sometimes, this could be the game itself that would serve in singleplayer. However, most often, this is just a server that's lightweight enough for the client to connect to and they play that way (it's also really nice to develop and QA this way, because many server bugs will also be seen by the client).

Now, one of the disadvantages here is: Can all remote clients connect to the host that the server (and one of the clients) is running on? Again, NAT traversal issues usually play a role here. In the first few days of any game that uses this, and only this, there will likely be a lot of issues with connectivity.

Another disadvantage: The host won't have latency issues. This is why in the case of, for example, Among Us, the client host can see certain things happening (like someone is dead the moment they hit a button or reported a body), but remote player hosts might not.

Okay, so, maybe it's not possible to rearchitect something like League of Legends like this. It could reasonably be a lot of work. Here is another solution:

Looks very similar to the first architecture, doesn't it? It is! The difference is that the text "Riot" was changed to "not Riot".

This is how World of Warcraft and Pokemon Go private servers work.

The vast majority of games that would not run without private servers simply do not require rearchitecting to keep in a reasonably playable state when the servers shut down.

[abdosh1999]

(via "Let me take a look at this I'm an engineer" Essential T-Shirt for Sale by Abdosh1999)

[debonairrose]

credit @lusi-1

[bigworldproject]

We are a social app built for people to share and celebrate everything bright & nerdy. We specialize in content related to engineering, medicine, comics, art, architecture, science, anime, gaming, and more. We plan to be the biggest content delivery system for everything nerdy.

[serafilms]

now why the fuck does genshin take up 80gb on pc