I would naturally read ⟨aw⟩ as /oː/ (as in e.g. ⟨hawk⟩), rather than /ɑː/. The weird part is the [e] — the only thing I can suggest is that they’re one of those people who raise /æ/ to [e] in some positions.
This whole thread is a comedy of errors stemming from different English pronunciation variants. The author of the original article evidently has the full Mary/marry/merry merger but maintains the cot/caught distinction, so "keh·ruh·kaw·ruhm" seems like a natural way of spelling the pronunciation. GP has the cot/caught merger but does not merge Mary/marry, so they read "keh·ruh·kaw·ruhm" as [kerəkɑːrəm] and understood this as distinct from Wikipedia's kær- pronunciation. And you don't have the cot/caught merger or the Mary/marry merger.
I just did a double take at "Windows and macOS aren't as bad as Linux".
Packaging for Windows is truly horrible. Even getting the dependencies to build your app on Windows is a nightmare (the author mentions winget which is no good for libraries)?
I maintain an app that uses libsfml, libfluidsynth and a bunch of other dependencies. Packaging on windows was only made possible by MSYS2 and pacman which is literally a linux package manager.
You're trying to force Linux-style packaging where declaratively specified dependencies from a single(-ish) repository and shared DLLs are a necessity due to intentionally hostile architecture of GNU/Linux for shipping binary-only software. You have to build everything as one single OS, because that's how Unix people did in 80s. Unix people weren't designing an OS for general binary software distribution.
You need to give up Linux-style thinking first. Windows-native tools like Visual Studio, WiX, MSI etc. make it nice and easy to vendor your own DLLs. They are designed for closed-source and binary-distribution first. And if the libraries are designed for this ecosystem, you just import them in VS.
If you don't want to give up Linux-style dependency management you can use source-based build systems. You can use `conan` as a source package manager to get something closer and then export every single binary dependency `conan install . --deploy=runtime_deploy --output-folder=dist`.
99% of applications on Windows will just include all their dependencies in a folder with the exe. It’s great — it works, it’s compatible, it’s simple!
Getting dependencies to build your app is definitely harder on Windows but the fact that you can just throw things in a folder for a binary distribution is unbeat!
> Packaging for Windows is truly horrible. Even getting the dependencies to build your app on Windows is a nightmare (the author mentions winget which is no good for libraries)?
The only sane way I've found to do this, is ensuring I never package it on a personal computer/computer with state, always a CI worker with fresh everything, isolated from everything else, with nothing assumed. Then for the packaging, define all required dependencies up front, and you won't end up with the typical "oh, I forgot to ship/package lib X and I didn't get any errors because I have it installed". Helps to set all this up with Nix too, can help you manage the VM lifecycle, and makes reproducible cross-platform a lot easier :)
You seem to be assuming building for Windows in a Linux-like flow. If Linux is a series of tubes, Windows is a truck. On Windows, you build the library and statically link it to your executable. The executable is one big monolith that doesn't get cut up into miniscule pieces like on Linux. If you really need a DLL for some reason, you use as few as possible, and put it right next to the executable. On Windows, binary artifacts are "heavy".
Of course this assumes your main product is an executable - if you're intentionally shipping a COM object or something, which is a DLL, different guidelines may apply. In that case you should still ship a "heavy" single-DLL COM object.
I don't think this is entirely accurate and in fact, I think you'll encounter limitations in how big the .exe could actually be, before the OS says no, compared to Linux or macOS where you can pack more into it. But still, on all platforms, you won't have multi-GB binaries, you have external resources which among them are DLLs and whatever, and the binary ("executable") itself ends up some MBs. At least most (if not all) of the large professional software I use on Windows is packaged like that.
Large professional software has components like COM servers, or several executables sharing the same app code which then goes in a DLL. What they don't do is divide up their DLLs any more than necessary. An open source library could be a DLL to comply with LGPL but it won't be one just because they can, while on Linux it would be a separate .so because it's separately updated.
I think this approach is misguided. Shipping your own DLLs is standard with Windows applications and good workflows using Visual Studio can quite easily can bundle everything you need.
If you need somewhat Linux-like build infrastructure, conan is very helpful to install all your dependencies and to create deployment packages.
Shipping in C:\\Program Files\\Your Name is standard with Windows applications; DLLs aren't shared between different applications like in Linux, so there's no reason to use them.
Additionally, the Windows dynamic loader doesn't squish all DLLs into one global namespace like the Linux one does. Every time you call a function from a DLL there is extra friction, even for the programmer.
There's also the libc linking problem. Each DLL may get its own copy for libc, either because they are statically linked or because they are compiled with different versions. If you try to fopen in one DLL and fclose in another, or malloc in one and free in another, it's liable to crash. This might've been solved in the 20 years since I learned about it, though.
> Shipping in C:\\Program Files\\Your Name is standard with Windows applications; DLLs aren't shared between different applications like in Linux, so there's no reason to use them.
Win32 and CRT (libc) is shared among programs, .NET framework DLLs are also shared. Industrial software does ship multiple .exes that depend on the same subset of DLLs. Anything that uses registered COM interfaces also use shared pages for the DLLs in memory.
> Additionally, the Windows dynamic loader doesn't squish all DLLs into one global namespace like the Linux one does. Every time you call a function from a DLL there is extra friction, even for the programmer.
This is an advantage of Windows over Linux where those squish into one unified namespace create compatibility problems and force the programmer to compile everything as a one single big universe / distro. It basically makes long-term backwards compat impossible.
Compile-time linked DLLs have no significant overhead compared to Linux after they are loaded and the loader has done its relocation work.
> There's also the libc linking problem. Each DLL may get its own copy for libc, either because they are statically linked or because they are compiled with different versions. If you try to fopen in one DLL and fclose in another, or malloc in one and free in another, it's liable to crash. This might've been solved in the 20 years since I learned about it, though.
This still kinda exists. However, Microsoft hasn't broken their CRT ABI since 2015. It is a feature not a bug IMO. All properly made libraries ship their own allocation and free functions for this very reason. It is not specific to Windows. This does happen with Linux shared libraries when they use their custom allocators. Giving up the ability to link with different libc versions, ability to link with multiple versions of the same library or good backwards compatibility is not a good tradeoff just to have a single global `malloc / free` call.
I always assumed those were statically linked into the binary or installer or something on Windows. Are people pulling down dependencies through the .msi?
Windows provides almost 100% of the system-level dependencies you need. You don't need to specify things like "I need gstreamer for video decode" or "openSSL for my network". Those are all part of a standard Windows system and they have stable API/ABIs.
Only thing you ship with your application are the libraries specific to your app. If you use Qt, you ship Qt libraries as bundled DLLs. If you use Havok physics engine, you ship that as a bundled DLL.
MSI can trigger things like installing optional Windows components but it is not a package ecosystem like apt or dnf. It is more like dpkg or rpm.
I really want to use a scheme based operating system where all processes are continuations and people boot into a REPL instead of a unix shell. something like a modern version of the symbolics lisp machines. Instead of using fork() and exec, spawning a new process would be a call/cc. can you imagine?
I assumed the word was derived from "azul" but from the article, it's apparently derived from the Arabic الزليج (al-zillīj) and has no relation with "azul"
Portuguese here - many Portuguese words have origin from Arabic as Portugal has been conquered and occupied by "the Moors" in 8th~13th century. That's a long time!
Alentejo, Aljezur, Algarve, and many of the cities in the Southern part of the country have have Arabic origins.
So much so that the controversy over the use of “insha’Allah” by non-Muslims was missed by me, Portuguese has “oxalá”, and I could not understand the problem.
It’s funny how many words we use in Portuguese and Spanish that have their origin in the Moorish time.
> The Christians marched on the cry of ¡Dios ayuda a Santiago! "God save St. James!". They slew more than 5000 Muslims and James became known as "Matamoros".
OK, I'm going to go out on a tangent, and put this SE topic where they discuss why "James" is the English equivalent of "Santiago", because it didn't seem reasonable.
And the word from arabic comes, for both of them comes from persian for hte term lapis lazuli (lāžward) and suposedly this comes from sanskrit... but I ignore how it may sound in sanskrit.
Lapis Lazuli is cognate, both come from the same Arabic/Persian root. Apparently “azure”, “azul”, “azzurro” lost the L because it got confused with the common “l’” article,
Azul 100% comes from Arabic (well Persian, but through Arabic), although I think the specific Andalusian form that was borrowed was a bit different from that.
none of which is [kerəkɑːrəm] as the author suggests
https://en.wikipedia.org/wiki/Karakoram
https://en.wiktionary.org/wiki/Karakoram
reply