JZerf

I also like the aesthetics of OS X versions prior to 10.10. It is hard to find programs that still support older versions though. To make things easier I'm using the more modern macOS 10.14 but installed a few things to make it look more like 10.9.

The file and instructions in https://forums.macrumors.com/threads/mavericks-window-contro... change many of the UI elements to look like those in 10.9.

Menu Bar Tint (https://manytricks.com/menubartint/) can make the menubar look like the one in 10.9.

macOSLucidaGrande (https://github.com/LumingYin/macOSLucidaGrande) can change the system font back to Lucida Grande like 10.9 used. One annoyance with this though is that the '*' character won't show up in password input fields.

I'm actually typing this reply on a 2012 MacBook Pro which is still working pretty well. I've also used several recent MacBook models at work so am familiar with those. Things that I like better about the 2012 MacBook Pro compared to newer models is that it's easier to replace/upgrade items. On my 2012 MacBook Pro I've replaced the original hard drive with a SSD, upgraded the memory, and replaced the failed battery (which shouldn't be unexpected for such an old laptop) which were all fairly simple to do.

I also do not like that Apple has completely removed all USB type A ports on the newer MacBooks. USB type A plugs are still very common and I wish Apple left one or two on the newer MacBooks in addition to the USB-C ports. Yes, you can use USB-C to USB type A adapters but it is annoying.

I also do not like that Apple has removed the Ethernet and microphone jacks. Both jacks are still useful to have on modern computers. I'll make an exception for removing the Ethernet jack on the MacBook Air to accommodate a thinner chassis but wish the MacBook Pro chassis was kept thick enough to accommodate the Ethernet jack.

This depends on how the organization configures things. My company used to allow TOTP so many TOTP apps could be used instead of Microsoft Authenticator but my company disabled that a while ago. Now the only authenticator app my company allows is Microsoft Authenticator using push notifications (see https://learn.microsoft.com/en-us/entra/identity/authenticat... ). Consider yourself lucky if your employer allows you to use any TOTP app you want instead of forcing you to use Microsoft Authenticator.

Those lunches could add up to something significant over time. If you're paying $10 per lunch for 10 years, that's $36,500 which is pretty comparable to the cost of a car.

Found the page I had mentioned earlier: https://pawitp.medium.com/the-correct-way-to-use-secure-boot... . In the comments Aleksandar mentioned the possibility of using the attack mentioned in this article and the author replied back with the same solution of verifying a secret file on the root partition.

I was reading another web page (I don't have the link unfortunately) several days ago where another reader pointed out to the author the same type of attack mentioned in this article. To address that attack the author came up with the same solution you proposed and I do believe that is sufficient for preventing the type of attack mentioned in this article. There still are other types of attacks (cold boot attack, sniffing TPM traffic, etc...) that can be done though so it still is a good idea to use a PIN/password, network bound disk encryption, etc... in addition to the the TPM.

I'm currently working on setting up disk encryption for a new home server and as an additional precaution I'm also working on getting the initrd to do a few additional sanity checks prior to decrypting a LUKS partition and prior to mounting the root file system within. One check which I think will be highly effective is that prior to decrypting the LUKS partition I have the initrd hash the entire LUKS header and make sure it has the expected value before allowing the boot to continue. So far it seems to be working OK but hashing the entire LUKS header is overkill which will require some care to make sure the expected hash value is kept updated if the LUKS header changes for some reason (like changing encryption passwords). I can not recommend this idea for everyone consequently.

But presumably he's writing other files to disk too. Not just that one file.

Yes, there will be much more going on than the simple test I was doing. The server will be hosting several VMs running a mix of OSes and distros and running many types types of services and apps.

One knob you could change that should radically alter that is zfs_txg_timeout which is how many seconds ZFS will accumulate writes before flushing them out to disk.

I don't believe that zfs_txg_timeout setting would make much of a difference for the test I described where I was doing synchronous writes.

On Linux, I think journald would be aggregating your logs from multiple services so at least you wouldn't be incurring that cost on a per-program basis.

The server I'm setting up will be hosting several VMs running a mix of OSes and distros and running many types types of services and apps. Some of the logging could be aggregated but there will be multiple types of I/O (various types of databases, app updates, file server, etc...) and I wanted to get an idea of how much file system overhead there might be in a worst case kind of scenario.

I sure hope I've upgraded SSDs by the year 2065.

Since I'll be running a lot of stuff on the server, I'll probably have quite a bit more writing going on than the test I described so if I used ZFS I believe the SSD could reach its rated endurance in just several years.

One reason why it might be a good idea to use higher quality drives when using ZFS is because it seems like in some scenarios ZFS can result in more writes being done to the drive than when other file systems are used. This can be a problem for some QLC and TLC drives that have low endurance.

I'm in the process of setting up a server at home and was testing a few different file systems. I was doing a test where I had a program continuously synchronously writing just a single byte every second (like might happen for some programs that are writing logs fairly continuously). For most of my tests I was just using the default settings for each file system. When using ext4 this resulted in 28 KB/s of actual writes being done to the drive which seems reasonable due to 4 KB blocks needing to be written, journaling, writing metadata, etc... BTRFS generated 68 KB/s of actual writes which still isn't too bad. When using ZFS about the best I could get it to do after trying various settings for volblocksize, ashift, logbias, atime, and compression settings still resulted in 312 KB/s of actual writes being done to the drive which I was not pleased with. At the rate ZFS was writing data, over a 10 year span that same program running continuously would result in about 100 TB of writes being done to the drive which is about a quarter of what my SSD is rated for.

Gran Turismo 4 was the last Gran Turismo for the PS2. It also did support networking for LAN gameplay but networking isn't required to play the game.

Additionally, there are multiple reasons why one programming language might have nine different programs:

-The programs could have been written by someone who prefers to make small iterations and perform many submissions instead of someone who likes to make bigger changes with fewer submissions.

-The programs could be submitted by a novice who needs to make more submissions than would be required by a pro.

-The programming language may be older and has had more submissions.

-The programming language may be more actively changing and requires more updates in order to fix old programs.

-The programmers may also be making more submissions to improve other characteristics like memory usage, code size, code readability, compatibility, etc... that are unrelated to performance.

You could certainly make an argument that an easier language allows a programmer to reach a certain skill level faster or maybe even reach a higher peak skill level. By extension you could also argue that, by some definitions, the skill level of that language's community might be higher. However assuming you had equally skilled Rust and Zig programmers, I think it is wrong to say that the Rust programmers would require more rewrites to match or surpass the Zig programmers.

It's not a good idea to use this site (or the Computer Language Benchmarks Games https://benchmarksgame-team.pages.debian.net/benchmarksgame/ that it is partially based off) as an indicator of how may rewrites are necessary in order to generate good programs. The skill levels of the contributors and the size/popularity of the various programming language communities can vary a lot. The benchmark rules have been changing over time and contributors have been figuring out better algorithms over time so these both result in the contributed programs getting updated over time as well. Older programming languages have been around longer than newer programming languages and will have had more contributed programs consequently. Some programming languages are under more active development so require more revamps of existing programs. Etc...

DreamBerd is a multi-paradigm programming language, which means that you can delete the keywords and paradigms you don't like.

  delete class!
  class Player {} // Error: class was deleted

  delete delete!

I was a little puzzled by this compared to what I was used to with Java in the past. It looks like the grandparent's code relies on JEP 445 ( https://openjdk.org/jeps/445 ) which is a preview feature as was mentioned but it also apparently requires the very latest Java 21 which hasn't even been officially released yet.

You might have an ad blocker installed.

Tarpitting in general can be fun. I have an iptables rule set up on my mail server that limits incoming SMTP traffic from suspected spammers to just three packets per minutes (which is still fast enough for a legitimate mail server to deliver your typical, less than 250 KB email in under an hour in case you accidentally ensnare a legitimate sender) and I've seen it often tying up spammers for 15+ minutes at a time. Below is a sample of a rule I might use in case anyone else is interested:

  iptables --append INPUT --source 1.1.1.1,1.1.1.0/24 --protocol tcp --dport smtp --match hashlimit --hashlimit-name HASHES_FOR_PROBABLE_SPAMMER_THROTTLING --hashlimit-mode srcip --hashlimit-above 3/minute --hashlimit-burst 1 --jump DROP

There are quite a few addons for Firefox for improving Facebook, here are three that I found right away and there are plenty more:

https://addons.mozilla.org/en-US/firefox/addon/socialfixer/

https://addons.mozilla.org/en-US/firefox/addon/disable-faceb...

https://addons.mozilla.org/en-US/firefox/addon/fbcleaner/

Facebook does make changes from time to time which makes it a bit of a cat and mouse game to keep these things working and that can easily get tiresome for people. Also some people might find the initial time investment to create these things to be too much.

There is another post in this thread where someone mentioned that for many people (but apparently not all???) including myself, browsing to https://www.facebook.com/?sk=h_chr tends to show your friends' posts in chronological order like many of us prefer. There are also several people who mention that using ad blockers like uBlock Origin do seem to be fairly effective at blocking most ads and other unwanted suggestions in Facebook and it does seem to work for me.

This is one of the major reasons why I try to limit my use of websites for anything important and prefer to use normal, local applications that don't rely heavily on someone else's servers. It's a lot harder for other people to stop you from using the applications and also helps prevent things from changing/breaking all the sudden.

That's kind of interesting that it currently transpiles to C++. I have a suspicion though that using C++ as an intermediate language will probably often result in lower performance, higher memory usage, make debugging more complicated, etc... than if it was compiled directly to a lower level language like assembly or LLVM IR. If I'm right about that, those wouldn't be very good characteristics for a programming language that you intend to make a complex web browser in.

In zamadatix's reply to your message he said that C++ is only being used to bootstrap the language and that it's certainly not the plan to require C++ forever. I imagine if Jakt thrives, he will be right and Jakt will probably start compiling into a lower level language instead. If they do target a lower level language though, I imagine this will result in Jakt being less portable than C++ which has been around much longer and is more established.

This is something I want to know too. C++ certainly has some issues like pretty much every programming language does but in the original article Andreas mentions that he wants to make a cross-platform browser and cross-platform, portable applications is one of the areas where C++ can excel. If they end up switching to Jakt, I fear this will greatly limit the platforms that Ladybird can run on.

I believe this relies on quite a few of the libraries in SerenityOS and according to one of the lines [1] in one of the build scripts for that it looks like Clang 13 will be required as a bare minimum. The Serenity project is also using the fairly recent C++20 standard according to their contributing document [2] and they additionally are working on a new programming language of their own called Jakt which I imagine will become a requirement in the future. For the time being, it looks like this will make it harder to support older environments which is a bit unfortunate because their browser project does look really interesting.

[1] https://github.com/SerenityOS/serenity/blob/master/Meta/sere...

[2] https://github.com/SerenityOS/serenity/blob/master/CONTRIBUT...

In addition to the reasons that mholt mentioned in response to your question, enabling HTTP/GZIP compression could possibly be less secure for some web server configurations due to things like the BREACH attack. See https://en.wikipedia.org/wiki/HTTP_compression#Security_impl... and https://en.wikipedia.org/wiki/BREACH for more info. I might be wrong but I don't think that current web serving protocols mitigate an attack like this. It might be better to default to safe settings that don't use HTTP/GZIP compression even if it might slow things down for the time being.

There was a research paper at https://greenlab.di.uminho.pt/wp-content/uploads/2017/10/sle... a few years ago that attempted to evaluate the energy efficiency of many programming languages and that paper got a moderate amount of attention on the web [1] [2]. It probably shouldn't come as much of a surprise but programs that require less clock or CPU time can and usually do result in less energy usage. This paper and this video just help prove that a bit more.

[1] https://news.ycombinator.com/item?id=15249289

[2] https://news.ycombinator.com/item?id=24642134

I think some more effort should be made in getting the default memory usage down to a more reasonable level. This site https://programming-language-benchmarks.vercel.app/problem/h... shows a simple Hello World Julia program as using 169 MB of memory (and I saw similar memory usage on my computer running '/usr/bin/time julia -e 'println("Hello World!")'') which was the third worse of all the programming language implementations that were tested.

Thanks, I hadn't noticed that Julia was also doing compilation during the benchmarking and I'm curious if it would be hard to get those benchmarks to be done with PackageCompiler.jl. With that being said, the memory usage still seems very high. For many of the problems, Julia is often using the second most memory of all the programming language implementations being benchmarked and several of those other programming languages implementations (Node.js, OpenJDK, .NET, etc...) also are doing some sort of compilation during the benchmarking as well. I also tried compiling several of the C programs with GCC and GCC usually only used ~30 MB of additional memory so even if you add that to the the memory usage of the C programs, it's still much less than the Julia programs. Using PackageCompiler.jl does look promising but that does add another step which looks to be slightly more involved (looks a bit comparable to using profile-guided optimization) than compilation steps for other programming languages and some could see that as another problem for using Julia in real projects.

It seems to use a lot of memory which can be unacceptable for many people and can become impractical if you plan on running several programs simultaneously. For several of the problems at https://benchmarksgame-team.pages.debian.net/benchmarksgame/... on the Computer Language Benchmarks Games, it shows the Julia programs as using several times more memory than similar Java programs. It's even worse when comparing to C, C++, Rust, etc...

Just wanted to point out that it looks like people will be able to go over that limit but will have to pay extra for it according to https://docs.gitlab.com/ee/subscriptions/gitlab_com/index.ht... . Seems somewhat reasonable.

All of the reasons you gave for removing optical drives are true for consoles but I'd also like to point out that even desktop and laptop manufacturers have been removing optical drives as well. The reasons you gave largely do not apply to computer manufacturers yet they have still been removing them. Optical drives aren't needed as much as they used to due to software distribution over the Internet so many computer manufacturers have been removing optical drives to reduce computer prices, make computers smaller, etc...

I'd also add that distributing an installation file that requires no activation server is also sufficient. Physical media is getting kind of dated as seen by many devices no longer even including optical drives.