The SONAME is the filename used for runtime linking. On the filesystem it may or may not be a symlink but that does not concernt the linker. It may not be (and usually isn't) the same filemame used when bulding the binary. This is because the SONAME is meant to specify a specific ABI version of the library.
Static linking uses the DT_SONAME of a linked library to create an entry in the DT_NEEDED table. The name in the DT_NEEDED table is used by the dynamic loader to search for a matching filename to load in. So in a very indirect sense the dynamic loader always uses the SONAME that was supplied at build time, but it also uses a search algorithm to find that filename at load time.
This reminds me of long ago when Usenet users were afraid of the NSA eavesdropping. In order to overwhelm them folks would include likely search terms in every post, such as nuclear or assassinate.
Aren't you assuming that the healthcare system operates for the good of the patients? From my point of view, that doesn't seem to be the case in the U.S.
In all these cases, there is one constant: the patients get treated, and treated well. That's not the issue. It operates for the good of the patients (whereas for example, the NHS often gets criticized ...)
The NHS is being systematically destroyed by the Tories who want this broken US system in the UK because it makes them money.
Aussie healthcare is the best I've seen (and I've seen a few). Basically free, with more speed or better care (or whatever) if you want to pay for it. Health insurance is like US$75 a month and not tied to employment.
Absolutely anyone who’s ever dealt with healthcare system will tell you otherwise. From being denied necessary medical procedures because insurance doesn’t agree with it to subpar quality of care because how stretched the doctors and healthcare professionals are, US medical system is far from treating everyone well.
The original name was .SCCS. I put the SCCS strings in there to save memory. In the early 1980s, the 3B20 computers used to manage the U.S. phone network had a 32MiB memory limit. By 1985 the network had outgrown that memory limit, by just a few kilobytes. So I hacked the C compiler to look for #(*) strings and put them into .SCCS rather than .data. Since .SCCS didn't load into memory by default, I saved just enough to run one more process! Each binary was built from about 2,000 source files, so those strings added up to a significant amount of memory.
This was at Bell Labs Columbus Ohio. Also, I think it was COFF and not ELF. Used System V r2.
>Eiswert determined that Darien had submitted the payment to the school payroll system, bypassing proper procedures.
How did he allegedly bypass payroll procedures? An athletics director should not have passwords to the school payroll system. I wonder if social engineering was used? In any case, their security procedures need an audit!
The problem with this is that wind speed alone is not a good indicator of how destructive a storm can be. Storm surge, mud slides, etc., contribute and can be deadly even in a category 1 or 2 storm. If the scale is to be updated, it would be beneficial to include other factors in addition to wind speed.
The enhanced fujita scale for tornadoes takes into account an assessment of damage after the fact to make a guess of the wind speeds that were produced. An after-the-fact assessment of hurricanes could be useful in creating a categorization that better communicates risk to persons than just windspeed.
Maybe, but the Fujita scale can greatly under report strength, because the higher grades need to be justified by damage to modern, well built structures. There are tons of tornadoes that meteorologists are sure are at least EF-4 based on Doppler and video, but are rated at EF-1 or EF-2 because they didn’t hit anything but cornfields and sheds.
This had wind speed measured by radar, but ultimately didn't hit any substantial structures, so they couldn't justify anything above EF3. Tornadoes are only rated based on the damage they do to damage indicators, the wind speeds are just best guesses.
I think that's also the challenge of using the same categories/windspeeds of the Saffir-Simpson scale when applying it to a place like Jamaica vs Houston. Both places may face a cat4 hurricane and see very different levels of damage entirely due to the difference in infrastructure.
Its a matter of informing people how to use the scales - we have temperature and wind chill but people still need to know that -40° will hit the Midwest much differently than -40° would hit Texas.
It can lead to a false sense of security... maybe if it turns east instead of north east it barrels into downtown Omaha.
In the most extreme case a small tornado in a larger storm that hits no man-built structures may go totally unrecorded.
Essentially if you assess tornado risk as something like (frequency * severity) / area, this will under assess risk to a previously developed area that is now being developed. Before there was nothing to hit. Now there is.
A well placed tree can make any storm deadly, it's perfectly fine to separate the size of the storm from the potential impact. You need to draw a line somewhere. Drawing it at the part you can measure/predict is pragmatic and sensible.
Poor Turing must be rolling over in his grave. The so-called Turing test was common before Turing wrote his rebuttal, calling that test little more than a Gallup poll (i.e.,just a subjective opinion). He proposed an alternative test, the real Turing test, that could provide statistical evidence. In his test, observers tried to distinguish between a woman and a man pretending to be a woman. This was repeated as often as you wanted to gain statistical significance. After that, a machine is substituted for the man and repeated as before. Turing claimed if the machines and the men had the same success rate, you should conclude the machine was thinking.
Lombok's headaches are because they are touching Java compiler internals to accomplish their magic. This won't fix that.
Lombok wouldn't be nearly as troubled if it was just doing simple bytecode manipulation.
If lombok wants to stop the pain, then they'll need to stop reaching into internal APIs. They'll possibly need to remove a few features (like some of the `private final` work they are doing).
In other words, you can expect lombok to be a headache for years to come. (Maybe consider not using it? That'd be swell. Speaking as someone that curses lombok everytime jdk updates roll around.)
Why isn't Lombok just written as a pre-javac pass? javac(lombok(srccode)). Just gotta keep that parser alive and up to date, which open source IDEs also must so they're probably available.
Manipulating the AST would be fine, but Lombok pretends to be an annotation processor (which can generate new classes, but not alter the semantics of the class being processed). They could create lombokc and crack open the internals of the Java compiler as much as they like, but this would mean admitting they are really Java, and they don’t seem to want to accept that.
Lombok should not be touched, esp. since records have been available. Morealso, lombok is just a sugar coating during compilation time.
Even before records, just use public final fields, and be done with the getter/setter nonsense. (IDEs do a good job of offering options for toString(), and c-tors)
Personally, I consider lombok one of the better anti-patterns widely used.
Lombok can be used for more than just getters/setters.
I personally use the @Builder annotation on records with more than 3-4 fields. I find it much more readable than a long list of arguments to the constructor.
It also makes it easy to return a copy of the record where only a few fields have changed:
var r = book.toBuilder()
.lastUpdated(now)
.title("...")
.build()
I also use other annotations, but I could work without them if a future version of Java provides a builder-like pattern (or named arguments)
Totally, and the With annotation is a bliss. Hope to have it at a syntax level someday, just like in Kotlin. In addition, you can decompile Lombok annotations straight into your code proper and change what you need, Builder methods for validation, say. Lombok is great for DX, especially if you have experience with more recent languages.
Records are the way to go, but there are many situations where the ecosystem doesn't work with them e.g. if you're stuck using something like Hibernate.
Lombok is a compiler extension, where this is an API for the JVM. So two very different things. Think of Lombok/compiler extensions as #include directives in C... things that happen at compile time. This API is for writing programs at runtime, past the compile phase.
Lombok is not a compiler extension. Compiler extensions, aka annotation processors, are offered only specific capabilities that ensure that they preserve the Java language specification. Particularly, code that compiles successfully with an extension also compiles without it (perhaps requiring other classes to be available) and it compiles down to the same bytecode. Annotation processors are used to implement pluggable type systems (e.g. https://checkerframework.org) or to generate other classes (e.g. https://immutables.github.io/).
Unlike compiler extensions, Lombok compiles source files that do not conform to the Java language specification. Lombok is an alternative Java Platform language, like Clojure or Kotlin or Scala, except that it's a superset of the Java language. However, rather than forking `javac` source code and modifying it to compile Lombok source files, the Lombok compiler modifies `javac`'s operation by hacking into its internals and modifying them as it runs to compile Lombok sources rather than Java sources.
Having alternative Java Platform languages is perfectly fine. The problem with Lombok is that it doesn't present itself as such but as a library or a compiler extension even though it violates the Java language specification in ways that compiler extensions are forbidden from doing.
Last time I checked, admittedly several years ago, Lombok was abusing the fact that the AST esposed to the annotation processors was mutable (exposing a deep immutable view over a complex data structure is not something that you do easily nor efficiently in Java to this day, so I'm not blaming javac here). The compiler estensionions were not really forbidden in any meaningful way to do what Lombok is doing, and given the difference in tooling and effort required for a new language I don't really blame them either.
That said, going against the whishes of the JSL has its risks, but I can understand Lombok's choice.
I still push against Lombok in the projects I work on since how it works makes me unconfortable.
There's nothing wrong with offering an alternative language or even with basing another language's compiler on javac. What's wrong is the misrepresentation of what they're doing and how they try to hide the technical risks involved from their users. Don't call yourself a Java library if you're really a different language that's very much not Java; don't say you're a compiler extension if you bypass the compiler extension API and reach into its internals (that can change at any time, BTW) to turn it into a compiler for your new language. Their choices are fine; telling users they've chosen something else is not.
reply