Service oriented architecture Puns

I'm a neophyte trying to understand home automation setup (where I would program my own hub in something like Python). I have a decent amount of software engineering experience.

My idealized scenario is that I make a hub which is basically a service, which does stuff like (1) maintain whole-house state in some backend, (2) interact with devices by submitting requests and receiving responses, (3) updating state based on responses, (4) updating action plan or next step based on how state evolves (in conjunction with some fixed or user provided parameters).

Basically in short, I would really like to think of every device as just another software service. I would like to think that these services are easy to talk to (in the sense of not needing many separate bunches of specialized code) and have transparent API's (so it's easy to tell what request would shut the device off, or request current temperature, or whatever).

It would be nice (but not necessary) if there was a standardized API which abstracted away from the deep details of device brand, etc., and permitted interaction via a set of predictable commands in a clean pre-existing interface (like "OK this thing implementsThermometer(), so I'll call its "getCurrentTemperature()" function).

To what extent does the above already exist? For example,

• Are there a ton of different incompatible ecosystems [i.e. protocols + API's + codebase] that all conform to the above?
• Is there one standard ecosystem (involving interfaces, etc.) that everybody agreed on, which smart devices reliably conform to?
• Is it a complete mess, and there are many ecosystems and you only know what ecosystems or interfaces a particular device conforms to by looking at its instructions?
• Are there smart devices whose interfaces are totally opaque, so that you have to "hack" it in order to even figure out how to get the temperature from code?
• Do some ecosystems block you from writing your own hub from scratch?

Thanks for any insight and pointers.

So all the sources I have are either very short or very "words words words" on this without any examples. I want to make sure I understand the concept behind this so I'll give you my understanding and we'll work from there.

So the way I understand SOA is that you design software using services that already exist so you don't have to design and implement them yourself. Your job is to link them together to create working software.

For example: We build a webpage. We use paypal for payment processing. Is that an example of SOA? I just integrate that on my webpage and I'll build whatever is necessary to make it work on my end. In this example:

Paypal would be the service provider. They implement the whole payment processing on their end. Who would be the service broker? Is my webpage the service consumer (because my webpage uses that service)?

If my example is correct, I have a few questions still: Why is scalability a big thing in the conext of SOA? All I do is delegate stuff to someone else? How does my webpage scale well because of that? Isn't the service provider the one to worry about scalability? Because all I would do is to link the services together.

Isn't the interoperability aspect just that I link these two together?

The Resuability and "loose coupling" aspect is just that I could replace one service for another if I need to, right?

Or is it more like:

I can exchange my MySQL for Postgres in my Data layer (thinking of three-layer architecture)

Service-Oriented Architecture (SOA) is an architectural approach in which application is develop using the services that are available on the internet.

SOA Vs Web services :-SOA is an architectural concept which focuses on having different services communicating with each other to carry out a bigger job. Thus, a web service is a basic building block in a SOA. When multiple services are combined, we have an application that falls under SOA.

service oriented architecture

I'm working on a monolithic PySpark project and have now an opportunity to refactor and redesign things a bit so was wondering what's your approach for code organization and composition, do you introduce any additional abstractions for your data transformers?

It seems like this topic in the context of pure data-oriented projects is quite poor... There is a ton of books and talks around software design but it often seems not applicable when building regular data transformers.
I started to dig into some potential functional programming approaches and I came across polylith but also no success with data context examples there.

Do you prefer an OOP/class-based approach or FP?

Currently we use python and are realizing it would be difficult to scale. We want something:

• With better performance
• Statically typed
• Well documented and supported, easy to integrate with everything we use currently

There would be a number of services with external REST apis as well as internal services talking with Thrift. It seems like currently Java and Go are the two main contenders. What are the pros and cons? I know performance is quite similar, with Go being slightly behind on most tasks(but that may change in the future).

I have read the Eric Conrad definition but still pretty lost about what this actually is and how it relates to the exam. Can someone provide cliff notes or key takeaways for this topic?

Currently we use python and are realizing it would be difficult to scale. We want something:

• With better performance
• Statically typed
• Well documented and supported, easy to integrate with everything we use currently

There would be a number of services with external REST apis as well as internal services talking with Thrift. It seems like currently Java and Go are the two main contenders. What are the pros and cons? I know performance is quite similar, with Go being slightly behind on most tasks(but that may change in the future).

(I posted the same question in the Go reddit, and decided to re-post here as one commenter suggested)