peterabbitcook

Would it be confusing if Simantic added support the Siemens Simatic S7-1500 PLC?

Probably because I tend to work more on the backend side of things (and a vague memory of a gumball machine example in my old “Design Patterns” textbook), I’m fascinated by the statemachines that are implied behind the scenes of these widgets.

That’s a tough question. If your PLC is on an airgapped LAN, admin/admin is not great security hygiene but you’ve reduced most of the risk by airgapping.

On my project the service I wrote was doing bidirectional communication with the PLC over OPCUA. The server running this pod was connected to the internet, so it was critical to have proper TLS for the OPCUA client/server. Rotating LetsEncrypt certs on the system every 45 days is a lot of toil, but using a self-signed cert that expires in 2040 from some dev laptop doesn’t pass muster in most organizations either.

That’s just the OPCUA path.. In these projects You also typically see WinCC HMIs that can talk to the PLC from anywhere on the network without TLS. And also SIMATIC Web Server pages - minimally secured by default, and the amount of info you can grok about the system in Chrome Dev Tools is troubling.

A couple years ago I worked on a service that had to communicate with a Siemens S7-1500 PLC. Based on my experience with that project, none of what I’ve read recently about unsecured industrial PLCs is surprising.

I opened Siemens TIA Portal and PLCSIM for the first time and thought “wow, I didn’t think the Windows 95 GUI library was still supported.” None of the PLC contractors we had hired knew how to enable TLS on the thing (user/pass eg admin/admin was their usual). Anecdote: I once spent hours reading the docs and clicking around trying to get it to accept an SSL certificate signed by a real CA and it wouldn’t go, but it accepted one I self-signed in openssl.

In all fairness, the people who are experts in the field of Siemens PLC programming are usually mechanical-ish engineers and security is not in their skill set or on their mind.

What are your feelings about using initContainers and wait-for-it to skirt the thundering-herd problem?

It made me think of the “step on all the colored tiles without crossing your path” puzzles in Links Awakening!

I wonder how the optimal path changes if turns are penalized as well as steps - in real life turning a lawnmower takes a lot more effort than moving the same spot twice in a straight line.

So under most brewing conditions a nonzero amount of this microbe survive, but that count is 3 orders of magnitude lower what might be termed a “therapeutic dose?”

What even is a good experimental design for probiotic tea? Brew -> agitate in hydrochloric acid & digestive enzymes for X minutes -> mix with billions of existing gut microbes (that may kill this microbe or out-compete it for resources) and incubate at body temperature -> count the number of new colonies of this particular microbe?

Though I guess using @decorator semantics would make it look a lot like python-numba syntax

I think I’m a little skeptical.

#pragma is a real keyword in C but # is just a comment in python - why not use a pythonic @decorator?

Vendoring a library like this into an app seems like a lot more toil than just writing the native multiprocessing python code, or using something built for number crunching like arrayfire or numpy

Where to stop is a pretty fuzzy question I suppose.

In my world, I think the worst possible outcome would be a java.util.json library that does 50-95% of what I currently do with GSON or Jackson. In that scenario I still need an external dependency, and I can either ignore java.util.json or turn a codebase into an error-prone mix of both.

Maybe a good set of design considerations for java.util.json would be “what does this API need to run a CRUD app written in modern java?” Parse requests from the web, send responses to the web, and serialize/deserialize data from X database (e.g. if noSQL or jsonb). In my head “in modern java” would mean that JSON is converted to records at application boundaries

Fick’s Law. The rate of absorption is proportional to the concentration gradient.

Reading this gives me considerable pause - I can’t think of many classes within the codebase I work on that don’t have @Slf4j at the top…

Since there wasn’t a link to the source code in that post, can you help me understand this - for the SLF4J baseline is your logger impl a console appender, a file appender, or a network service like an OTel collector? Does any of that matter for GC context?

In the Java-verse it’s also do-able with Guice. I’ve tried it with Dagger but bailed (square peg / round hole).

I think I prefer Springboot AOP, especially with SpEL.

The term “cross cutting concerns” is thrown around a lot when discussing AOP. Took me a while to appreciate just how powerful it is in this context - sprinkle an AOP annotation here or there to avoid massive refactors in a large codebase, or avoid rewriting classes in a way that makes your classes themselves “cross cut concerns.”

I’ve dealt with a question that rhymes with this.

Sonarqube or CodeQL reports might tell me what percentage of a repo is duplicated code, and a large percentage of that is in src/test/java

I find that a lot of the time this is not just some flippant observation but a clue that I should be using a mechanism like @ParameterizedTest instead of @Test, so I rewrite those tests in a way that makes them easier to set-up, define parameters/constraints, inputs, and outputs. Sometimes it does get a little convoluted as you either use a lot of naked Arguments.of() or define test-class-scoped nested records to encapsulate test parameters, inputs, expected outputs, etc.

So it’s not UL listed?

Do you need the 15V input to torch the capacitors and run the relays? Could I use a 5V USB ESP32 dev board instead, and just put a boost circuit or MOSFET on the relay load side for the explosion circuit when it needs to go off, or are there other components that need the higher voltage?

Really cool visuals, thank you for sharing this.

I feel like the importance of padding is a bit understated on this page - BLAS and LAPACK require LDA and LDB parameters, and you can definitely tune these to the page size of a particular system/machine to improve performance.

When working with BLAS/LAPACK or other matrix libs, you can often apply a little linear algebra to reshape the problem rather than the input data to avoid a transpose altogether

I’ve been skimming the source code and it looks promising for the stated use case. Wondering how to configure and set it up for a producer/consumer scenario where the producer puts compressed bytes on the wire and the consumer processes it; I can definitely see a use case where an edge sensor pumps compressed data to a cloud server with a GPU, though I don’t usually pipe doubles to a GPU.

Something worth thinking about that since you mentioned it’s geared towards “scientific” data streams. If we’re talking about precise measurements from instruments, your sensor is typically an analog signal which you digitize. Digitizers exist that can output floats, but DACs used in industry like a Rincon or Alazar (that sample at multiples of 100 MHz) prefer to output quantized shorts or ints that are rescaled to a float with a magic number (i.e. 32767/pi for a phase measurement, or gain/(16 mA) for industrial transducers) somewhere down the line. I bring this up because you pointed out your max throughput is about 120 MiB/s which would make it a big bottleneck for scientific data coming out of a digitizer that can pump out 800-1600MiB/s. 120 MiB/s throughput of doubles is not really that high for CPU level computations or network Tx bandwidth on modern hardware.

I recently finished reading “The Smartest Guys in The Room.” This definitely rhymes with some of the “energy efficiency” shenanigans committed by Enron’s EES subsidiary.

If you decide to pivot based on the comments in this thread about this turning into UberDrugz, an underserved market adjacent to this space is LTL freight.

For an example of this look for items on eBay whose shipping method is “freight.” As a buyer (or sometimes seller, if your buyer is clueless) of one of those items, it is your responsibility to arrange an LTL freight carrier (flatbed or liftgate truck). Fastenal and Uber freight will accept 1 pallet, up to a certain weight limit; you may even be responsible to bring it to a freight hub yourself. Above that size you’re on your own calling trucking companies, and renting a forklift or crane when you actually find a trucker.

It’s a smaller market than small packages, but more revenue per transaction. And if you figure it out and get it up and running, eBay (e.g.) might allow buyers and sellers to automatically select your service as the shipping method instead of black box “freight.”

Source = my personal experience 1. selling a metal building kit on eBay that the local zoning board would not let me erect. 2. Buying a large greenhouse kit online

mAh has always seemed silly to me as well. I get that the actual voltage of a battery is a function of battery charge %, load current, temperature and “other stuff”, but the battery designer/manufacturer knows all this… Why not just tell us how much energy is in it {,k,M}Wh or {,k,M}J?

It seems like it’s quite HTTP-centric (like most of the web…). I didn’t see anything on the page about this - can it also intercept / “reverse engineer” service calls that go over gRPC or WebSocket? I’m guessing at least a partial “yes” if the gRPC traffic uses grpc-web/Envoy?

Seems like a great product, potentially quite powerful for automated testing of SPAs.

I’m trying to wrap my head around the use case this was created for. If a python service dumps a numpy array to bytes and sends that as a payload to a C++ service, is that blob of bytes not interpretable by C++ as e.g. a struct with some size fields and a pointer to the start of the array? (Cutting out the filesystem/npy file)

Maybe I’m overthinking it but I can’t quite envision a use case where a python service and C++ service would be sharing a filesystem

I am curious, did you check how much your benchmarks moved (time and errors) if at all if you told the compiler to use —-use_fast_math or -ffast-math?

There’s generally not a faster version of inverse trig functions to inline, but it might optimize some other stuff out.

Unrelated to that, I’ve seen implementations (ie julia/base/special/trig) that use a “rational approximation” to asin, did you go down that road at any point?