giamma

In Epicureanism ataraxia is paired with ἀπονία (aponia).

Aponia is for the body what ataraxia is for the mind. You can find more details in the Wikipedia page about Epicureanism [1]. True pleasure comes from the absence of spiritual trouble and the absence of physical pain. The Latins used to say "mens sana in corpore sano" (healthy mind in a healthy body)

[1] https://en.wikipedia.org/wiki/Epicureanism

I have no direct experience, but apparently this is an historical problem. Way before the pandemic a friend of mine relocated to USA (from Italy) and started working for AWS as a product manager.

She did not last much and eventually jumped to another big company. Sure the job was challenging in AWS, but what she was complaining the most about was the speed at which people were leaving and being replaced.

She told me that she often had to schedule meetings with people from other teams/departments, sometimes 2-3 weeks in advance to find a free calendar slot, and when it was finally the date for the meeting, it often occurred that one of the invitees did not show up, without any prior notice, only for her to discover that the person resigned.

So very often she had to reschedule the meeting with different people and wait another couple of weeks for them to be available. This made it very frustrating and difficult for her to get things going, as she was a product manager for a product that required a lot of cross-team collaboration.

Based on documentation, ArcaNoae comes with support for large hard drives, newer video chips, USB etc etc.. I guess it should run on most hypervisor(s) or virtualization systems, provided you use a humble hardware configuration (e.g. no need to use GBs or RAM) even VirtualBox or KVM most likely will work. But whether it's supported by the hypervisor vendor or not is a different story.

Plain OS/2 did not receive any update for 20+ years, it's installer won't work on modern hardware/virtualization systems.

I think they are not really interested in individual users, they aim at corporations having legacy applications that run on OS/2 only, so the goal is to make the system virtualization friendly and runnable on more recent hardware.

That said, my understanding (as a former OS/2 user 3 decades ago), is that a community edition cannot exist because IBM and MS still hold the copyright and intellectual property and the software cannot be distributed for free.

Well, ArcaNoae is still under development [1] and community events are still being organized [2]

[1] https://www.arcanoae.com/roadmaps/arcaos/ [2] https://www.arcanoae.com/blog/

Same as you, but I cannot find a good configuration for the linkedin App to prevent it from sending me too many notifications. I get 5+ notifications per day related to "this message is trending...", "your contact posted this...", "you are invited to do that...." and buried between them, from time to time, contact invitations that are worth considering.

My guess: as I wrote in another comment, Elasticsearch had significant evolution in the area of "search engine", while OpenSearch trajectory (to use the wording of the press release) has been in the direction of APM/monitoring.

When Elastic changed the license, all vendors of APM products based on Elasticsearch jumped to OpenSearch.

Maybe, they want to pass the message that the fork, OpenSearch, is enough different to not represent real competition, and in any case, now that it exists, after the investment done, AWS will offer that as an alternative to Elasticsearch and not Elasticsearch itself but managed by AWS as it used to be before the license change.

Now, who wants a managed Elasticsearch service will only buy it from Elastic.

My understanding (after talking to several market analysts) is that OpenSearch is focused on APM/monitoring/log-aggregation, while Elasticsearch has an edge on pure search engine functionality and now AI.

That's because the license change by Elastic impacted not only Amazon, who could not provide Elasticsearch as a service anymore through its administrative consoles, but also all those vendors who were building APM/monitoring/log-aggregation solutions as-a-service on top of Elasticsearch. In fact, such vendors would typically use Elasticsearch as a back-end behind some custom UI.

So those vendors teamed up with AWS to develop OpenSearch.

Now last time I checked the commit history of the two projects, Elasticsearch had 3x more commits and many of them on cool new stuff, while OpenSearch focus seems to have remained on APM/log aggregation.

As someone who needs an actual "search engine", I am glad of the change, as I was worried OpenSearch may not be a viable open source alternative as it could be lagging behind in this domain.

Now I need to check what happens with the clients: will the client remain Apache License or will they change to AGPL? The latter would be a problem for closed source software.

Hello, this looks like a cool product, congratulations.

How does it handle the different UI guidelines on the two platforms?

I have not been using Android for some years, but the first example that comes to my mind is that as far as I remember Android has a platform-level back button, while on iOS each application provides a "back" link to be tapped to go back to its previous screen. If I wanted a single code base that followed the recommended UI approach on each platform in order to be as user friendly as possible, would I need to write certain parts twice using #IFDEF or similar blocks?

I have an android TV running Kodi. Kodi connects via SMB to my NAS (Odroid HC-4, OpenMediaVault) and can easily show all my content.

Would Jellyfin improve my experience? I could run it on odroid without transcoding, and then use the official android-tv client. Would it be worth the effort of switching?

When a real thread is allocated from a virtual thread to another, the JVM needs to save into the heap the stack of the first virtual thread and restore from the heap the stack of the second virtual thread, see slide 13 of [1]. This is in fact called mounting/unmounting as already pointed out, and occurs via Java Continuation, but from the JVM perspective this is a context switch. It's called JVM and the V stands for Virtual, so yes, it's not the kernel doing it, but it's happening, and it's more frequent the more virtual threads you have in your application.

[1] https://www.eclipsecon.org/sites/default/files/slides/JavaLo...

The JVM will need to do context switching when reallocating the real thread that is running a blocked virtual thread to the next available virtual thread. It won't be CPU context switching, but context switching happens at the JVM level and represents an effort.

You will still have to worry, too many virtual threads will imply too much context switching. However, virtual threads will be always interruptable on I/O, as they are not mapped to actual o.s. threads, but rather simulated by the JVM which will executed a number of instructions for each virtual thread.

This gives the chance to the JVM to use real threads more efficiently, avoiding that threads remain unused while waiting on I/O (e.g. a response from a stream). As soon as the JVM detects that a physical thread is blocked on I/O, a semaphore, a lock or anything, it will reallocate that physical thread to running a new virtual thread. This will reduce latency, context switch time (the switching is done by the JVM that already globally manages the memory of the Java process in its heap) and will avoid or at least largely reduce the chance that a real thread remains allocated but idle as it's blocked on I/O or something else.

Yes, at EclipseCon 2022 an Oracle manager working on the Helidon framework presented their results replacing the Helidon core, which was based on Netty (and reactive programming) with Virtual Threads (using imperative programming). [1].

Unfortunately the slides from that presentation were not uploaded to the conference site, but this article summarizes [2] the most significant metrics. The Oracle guy claimed that by using Virtual Threads Oracle was able to implement, using imperative Java, a new engine for Helidon (called Nima) that had identical performance to the old engine based on Netty, which is (at least in Oracle's opinion) the top performing reactive HTTP engine.

The conclusion of the presentation was that based on Oracle's experience imperative code is much easier to write, read and maintain with respect to reactive code. Given the identical performance achieved with Virtual Threads, Oracle was going to abandon reactive programming in favor of imperative programming and virtual threads in all its products.

[1] https://www.eclipsecon.org/2022/sessions/helidon-nima-loom-b...

[2] https://medium.com/helidon/helidon-n%C3%ADma-helidon-on-virt...

You are right but there is no legally defined threshold so it's subjective.

As a matter of fact, the Eclipse Foundation requires every contributor to declare that every piece of code is their own original creation and is not a copy/paste from other projects, with the exception possibly of other Eclipse Foundation or Apache Foundation projects because their respective licenses allow that. Even code snippets from StackOverflow are formally forbidden.

If I am not mistaken, in the Oracle-Google trial over Java on Android, at the end Google re-implementation of Java API on Android was considered fair-use, because Google kept the original "signatures" of the Java SDK API and rewrote most of the implementation with the exception of copying "0.4% of the total Java source code and was minimal" [1] However the trial came to this conclusion after several iterations in court.

[1] https://en.wikipedia.org/wiki/Google_LLC_v._Oracle_America,_....

You should give Theia Ide [1] a try. It's plugin-compatible with VSCode, same user experience. It's slower to start and takes more memory but on my 3 y.o. intel Mac it is definitely snappier than VScode.

[1] https://theia-ide.org/

Software like Blackduck or Scanoss is designed to identify exactly that type of behaviour. It is used very often to scan closed source software and to check whether it contains snippets that are copied from open source with incompatible licenses (e.g. GPL).

To be able to do so, these softwares build a syntax tree of what your code snippet is, and compare the tree structure with similar trees in open source software without being fooled by variable names. To speed up the search, they also compute a signature for these trees so that the signature can be more easily searched in their database of open source code.

With respect to auto-generating documentation, I was thinking about the possibility for annotation processors implementors to add javadoc comments or yet another annotation to their processor that JDK could use to dump a list of processors found in the classpath as a table with some information.

> javac <other parameters> -proc:info

some.library.Proccessor:

    scans classes annotated <whatever> and produces a file in META-INF/services
    for <some.library> to be able to load your implementation via ServiceLocator

some.otherlibrary.OtherProcessor:

    .....

With that table creating your inclusion/exclusion files would be easier

"This policy of implicitly running annotation processors by default may have been reasonable when the feature was introduced in JDK 6 circa 2006, but from a current perspective, in the interest of making build output more robust against annotation processors unintentionally being placed on the class path, the policy should not be the default anymore."

This makes sense, especially in light of the growing number of supply chain attacks. However, given how many libraries a typical Java application has in the classpath, most of which are transitive dependencies of popular frameworks, I foresee many build jobs not producing working binaries anymore when JDK23 is adopted. Plus, I'd love to be proven wrong, but I could bet that most people will fix the issue by simply adding the "all-on" switch to the command line instead of carefully evaluating which annotation processors are really needed by their codebase. So I am afraid that in the long term this change will not improve security or reduce build times. Unless maybe JDK 23 comes with some tool to print a catalogue of the annotation processors found in the classpath, with their respective purpose and documentation, so that developers can make an educated guess about what they need or don't need.

One of the killer features of terminal for me is that it's always clean and polished without fancy animations. You can possibly use transparency but that's more than a visual effect, it can actually be useful to let you see what's happening in a background window.

So while technically amazing, I do hope these text effects will never land in real world application, unless it's related to video gaming.

I believe they mean they removed the data, which was unused, from their own website.

Very well said.

It's not always true, a small but growing number of companies have ethics and solid principles and are becoming B-Corp [1] certified. I am lucky enough to work for one of such companies.

[1] https://en.wikipedia.org/wiki/B_Corporation_(certification)

> I'm well familiar with Opensearch now being the preferred choice over Elasticsearch

That's interesting feedback, I am using Elasticsearch and was looking into Opensearch as an alternative. What I see from their respective repositories is that Elasticsearch is more actively developed, it receives almot 3x commits in the same amount of time. Plus, as some of my clients want to install on-prem, it's not clear to me if you can get commercial support for on-prem installations.

In principle I agree that SSPL is "bad", but I understand the reasons behind it. Plus, I don't like the way article 13 is described, the intent was to be sensational rather than an objective analysis.

I think MongoDB and Elastic did not expect that AWS would simply repackage their product and start offering it as a service becoming a competitor. Technically the Apache License that Elasticsearch was using allowed that, but ethics should have prevented it.

AWS could have approached the vendors for an OEM agreement or some sort of partnership which could have resulted in a "win-win" rather than pissing them off, up to the point that they had to come up with the nasty form of block that SSPL is.

People are often complaining that SSPL is created to please investors and bla bla bla, but at the end, even if the software was open source, the company was never supposed to be a no-profit, so I don't understand where the scandal is, and why everyone blames Elastic or MongoDB and nobody blames AWS.

Can't talk for Linux, I am now using Eclipse on Mac.

I used Eclipse on Linux about 8 years ago, and I remember running into frequent issues at that time: the problem was that I was using Ubuntu 16.04, but the SWT widget toolkit maintainers for Linux were Red Hat employees and they were focused mostly on Fedora. For several months SWT was very unstable because the native nature of SWT made it difficult to support it on the different Linux distributions, especially during the transition from GTK2 to GTK3, and considering that Ubuntu was tweaking GTK a lot to achieve its own unique visual style. You can get an idea of the problems the Linux maintainers were having here [1]

At the same time, the release notes of Eclipse clearly stated that that particular version of Ubuntu was not supported. So maybe you are running into the same issue, maybe you are using a Linux distribution that is not amongst the list of officially supported (=tested) Linux distributions.

With respect to market place and plug-ins my experience is different from yours, but having worked on Eclipse plug-ins for years I am certainly a more expert user. As I already said, to me the worst aspect of Eclipse is the p2 package format. It probably solves many problems (e.g. it tries to guarantee that you don't end up with a broken Eclipse instance due to lack of dependencies), but I often think that they could have achieved the same by using plain-old Maven dependencies and BOMs.

[1] https://bugs.eclipse.org/bugs/show_bug.cgi?id=492371

Edit: fixed typos

At first I thought this was a test tool for Web applications, but now I understand it's meant to be a better RPA.

Would it be usable for test automation? Would API allow to create asserts?

Hi, I am an Eclipse Foundation committer, but I am not committing to the IDE itself.

You don't have to sign the CLA (contributor license agreement) if you want to report a bug, but you have if you want to contribute code, even a small patch for a bug you found. That's a legal requirement to protect the Foundation from contributions that may copy/paste proprietary code and to ensure that you will not in the future change your mind and make claims for your contributions. It's not peculiar to Eclipse Foundation, many open source vendors require contributors to sign a CLA [1]

My understanding is that Theia is currently more of a platform than a complete IDE. It is meant to be usable for building cloud-based IDEs, and you can test a distribution on your workstation, but being it a client/server architecture, you currently have to run a docker container locally to test Theia (or at least this was the case in Q3 2023). They are now focusing on the user interface and plug-in architecture of Theia (which is already capable of running VSCode extension). IMHO, for Theia to become really meaningful the server-side part needs to be improved: currently Theia reuses Eclipse JDT and other plug-ins on the back-end, which is fine for a desktop app, but less convenient for a client/server IDE as you will need a separate server-side container running the Eclipse plug-ins for every active user running the Web-based Theia GUI.

With respect to Eclipse itself, it has dramatically improved over the last few years, since the Foundation started making a release every 3 months. You may like the UI or not, but on my workstation it's now much faster and lighter than it used to be, and it's also faster and lighter than IntelliJ. To me the main issue with Eclipse is that it relies on P2 for plug-in distribution, which makes installing Eclipse add-ons a painful process.

[1] https://en.wikipedia.org/wiki/Contributor_License_Agreement

On MacOS in my opinion this theme makes the experience much better: https://github.com/ideaweb/firefox-safari-style

I don't know if they are the secret to success, but I agree that non-code contributions are extremely important.

For example, the Eclipse Foundation often reminds users that bug reports are valuable contributions [1].

[1] https://www.eclipse.org/contribute/