gwmnxnp_516a

It does not happen only with Banks, there are many cases where innocent people, that are flagged by fraud detection machine learning algorithms in social media or any kind of service, are banned or have accounts frozen without any explanation or warning due the false positives results or bias in the machine learning algorithms. In lots of cases, companies operating fraud detection algorithms don't provide any way to appeal and do not have any human in the loop for reviewing the decisions taken by the algorithm due cost saving or scaling. In general, no explanation is given to a person flagged by the algorithm in order to not disclose how it works or help bad actors. In the case of financial institution, other reason for no giving explanation is the legal AML requirement that forbids financial institutions from telling a customer that he or she was flagged. It is becoming a Kafkaesque world, the AI is more and more making decisions about our lives without due process and right to appeal/recourse.

Here some similar case:

  - AI tool flagged parents with disabilities: https://apnews.com/article/child-protective-services-algorithms-artificial-intelligence-disability-02469a9ad3ed3e9a31ddae68838bc76e

  - https://www.theguardian.com/technology/2022/aug/07/ai-eu-moves-to-beat-the-algorithms-that-ruin-lives

 - https://ico.org.uk/for-organisations/guide-to-data-protection/guide-to-the-general-data-protection-regulation-gdpr/automated-decision-making-and-profiling/what-does-the-uk-gdpr-say-about-automated-decision-making-and-profiling

 - U.S. warns of discrimination in using AI to screen job candidates : NPR / https://www.npr.org/2022/05/12/1098601458/artificial-intelligence-job-discrimination-disabilities

 - Finding it hard to get a new job? Robot recruiters might be to blame | Work & careers |/ https://www.theguardian.com/us-news/2022/may/11/artitifical-intelligence-job-applications-screen-robot-recruiters

 - https://www.vice.com/en/article/jgq35d/how-a-discriminatory-algorithm-wrongly-accused-thousands-of-families-of-fraud

 - Handling Discriminatory Biases in Data for Machine Learning - by Matthew Stewart, PhD (it shows how to make ML algorithms fair) / https://towardsdatascience.com/machine-learning-and-discrimination-2ed1a8b01038

The greatest cross-platform toolkit is Qt that abstracts away all platforms including mobile and embedded systems. Qt also works on top framebuffer on embedded Linux and on other RTOS operating systems. The disadvantage of Qt is that is a C++ library with a lack of C ABI or C api (extern "C") that would allow Qt to be called from other programming languages than C++. That is the reason why Gtk has far more bindings than Qt, although they are unstable due to Gnone breaking changes and lack of backward compatibility.

Most applications just pick Windows win32 API or MacOSX and forgets about everything else and are never released for Linux or other Unices, unless the application uses electron, Qt with C++, Qt with Python or Java SWING like JetBrains IDEA IDE family. The main problem of Linux desktop is the lack of a high level graphics library toolkit with a stable API, ABI and a C interface that does not introduce breaking changes on every release. Unlike Gtk, Qt is more stable, but it lacks a C API and C++ has a fragile ABI not friendly to foreign-function interface or cross-language linking.

The problem of creating GUIs libraries almost from scratch is the platform fragmentation, which means that a cross-platform GUI libraries would have to abstract away the Windows API win32, that is one of the most stable and most complete GUI libraries; MacOSX Objective-C Cocoa; Unix and Linux X11 - X Windows System, that lacks Win32 button and other higher level widgets, in this case it is better to use GTK as backend instead of targeting X11 directly that may even be replaced with Wayland on major Linux distribtions; Linux Wayland backend directly; Linux framebuffer for embedded Linux systems; or OpenGL for a immediate mode GUI like Imgui. Another trouble is that GTK is not so stable like Win32 and has many breaking changes on every release that may require anything depending on this library to be modified.

The following design patterns are widely used with graphical user interfaces: observer-design pattern; model-view-controller; model-view-presentation; two-way-data binding; property binding; command design pattern; and composite design patterns for representing a collection of objects as single object.

For understanding event loop it may be much easier to implement a Xterm or VT100 keyboard-driven terminal user interface TUI since this does not requiring dealing with too many backends.

The definition of what is inflation depends on the economic school of thought. In the case of the Austrian and Chicago economic school of thought inflation is the increase of money supply caused by the central bank that allegedly results in systematic and non temporary increase of CPI consumer price index and money loss of value. There are school of economics, such as Keynesian that argues that a limited and controlled inflation is a good thing for increasing market liquidity, avoiding deflation and promoting a full employment policy. On the other hand some economists believe that some inflation is also good for weakening the currency, boosting the exports and reducing the imports. Inflation becomes problematic when it is used for financing uncontrolled government spending like in Argentina, Turkey and Lebanon as making money out of thin air is the easiest way to a government to raise money since raising taxes can result in massive opposition; taking loans denominated in foreign currency may requires good credit rating and reasonable credibility; austerity measures, such as cutting government spending, unreasonable subsidies or unreasonable government employees wages may also result in political clashes.

The raise of money supply is not be the only cause of CPI and raise of cost of living as supply and demand problems around the world may also increase the CPI. For instance, we also should remember that we have faced several unexpected black swans, such as the pandemic; supply chain shutdown around the world, specially in Asia, that the West has become too dependent on; massive flooding in China what prompted the country to hoard grains; massive droughts in USA (California) and south of Brazil, both countries accounts for great deal of the world's food production; and finally the current war in Europe reduced the amount of natural gas, crude oil supply, fertilizers and wheat in the global market. Both countries involved in the current war accounts for about 1/3 of the world wheat production. Too much foreign dependency can also affect the CPI, since any currency devaluation against the dollar increases the price of everything if the country does not produces enough food to cover its needs like Lebanon.

But they are not officially supported plugins, while CMake has official support from major companies and IDE makers, namely Microsoft, Jetbrains, Qt Company. Further comments in this threads also pointed out that some Plugins for Clion are abandonware and may no longer work.

A reason for using Cmake is that this build system's CMakeLists.txt also works like a universal IDE-agnostic project file that saves the user from wasting time tinkering IDEs and lots of XML files in the case of Visual Studio MSBUILD building system.

In order to Xmake reach the mainstream, it needs to be supported by major IDEs. The major advantage of CMake over all other building systems is the broad range of IDE support. One can open CMake project without even touching the command line with Visual Studio Code, Visual Studio IDE, Eclipse IDE, Clion or Qt Creator and immediately get support for code exploration, code completion, refactoring and so on.

This node npm supply chain attack incident is a wake up call that the current security model of mainstream operating systems such as Linux, MacOSX or Windows are no longer suitable for modern day threats and they need a "zero-trust" like model for applications. Mitigating supply chain attacks like this one requires adopting application sandboxing by default, assuming that any application can be compromised, and capability-based security model like Fuchsia, Genode OS or mobile operating systems like Android or Apple's IOS. In the case of Linux, the most suitable sandboxes are docker container and Firejail tool that can restrict operating system resources which an application can access, including the $HOME directory. Firejail can even provide a fake $HOME directory. In the case of Microsoft windows, there is the Windows Sandbox, but it is only available on Windows pro or enterprise. But even so those countermeasures would only prevent the user data from being damaged, malicious NPM packages could still attempt to send credentials, tokens or database information back to the attacker. More details at: https://hkubota.wordpress.com/2020/12/31/comparing-sandboxin... and https://docs.microsoft.com/en-us/windows/security/threat-pro....

Another suitable mitigation strategy may be lock dependencies version or switch to other programming languages with a proper standard library and limited number of packages where one can at least audit the code.

Brazil has only itself to blame. Not only Apple products, but several other technology items are pretty expensive due to the VAT (Value Added Taxes), namely, ICMS - state vat tax, IPI - federal vat tax for manufactured products, IOF - federal government tax that incurs on financial trasactions, and high import tariffs. All tariffs and taxes almost doubles the price of everything imported and whenever a product is sold to a distributor and the final seller, state and federal VAT taxes adds up increasing the price even further. Unlike the global north, most of taxes revenues in Brazil come from VAT taxes since brazilian middle class is not willing to pay higher income tax and at the same time they want US-style taxes and European-like lifestyle, such as ree healthcare and free college that are paid in Europe mostly through income tax revenues and dividend tax revenues. So despite higher taxes, it it is not that bad for the upper class and those who can afford Apple gadgets as they would have to pay higher income taxes if they moved to Europe, US or other countries. In Brazil even dividends are not taxed, while in US and Erope they are taxed and companies have to use stock buybacks in order to avoid double taxation.

It depends pretty much on your field. If your field is related to games, formulas related to quaternions, linear algebra and coordinates will be useful; if your field is related to data science or machine learning, then, statistics, linear algebra, tensors and optimization will be useful as well. Obviously some types of programming requires more math than others, a robotic-related programming certainly will require far more math than a vanilla crud application.

Better to stick with CMake due to broad range of IDEs supporting CMake, including, Visual Studio, Visual Studio Code editor, Jetbrain's CLion, QtCreator, KDevelop IDE and also Eclipse IDE via plugin. Other building systems may even be better than CMake, but they may lack widespread IDE support. By using CMake a project can make it easier to other people contribute as all they need to do in order to navigate across a C or C++ project is opening a directory containing a CMakeLists.txt file.

Another advantage of CMake over Meson is that CMake is Turing-complete, supports user-defined functions and macros, and has capabilities to download other packages and sub-projects by itself. It is also worth mentioning the CMake ability to deal cross-platform annoyances such as, exporting DLL symbols, making symbols private, installing to a directory, compiling resources on Windows and so on.

Not a founder. The catch is that docker fixes the Linux dependency hell problem that stems from the fact that the server Linux distribution may not have the dependencies you need for running your application and if you install your dependencies that are not in the distro repository, such as shared libraries or other executables, that may override the existing ones and mess the system or break something. Even a native executable may fail to run in the server if it is using an older version of version of GlibC than the one the application was linked against. Therefore, this problem may also affect ruby and python libraries written in C, C++ or Fortran. Other advantage is that docker reproduces entirely the development environment and encapsulates its configuration. So, docker also saves time that would be spent on manual system configuration chores, editing configuration files, creating symbolic links and so on. By using docker or any other container technology such as Podman from Read-Hat one can also get pre-configured and pre-made systems up and running quicker and also swap the configuration.

A reason, for not using docker would be when using any application written in Go (Golang) since Go static links almost everything and does not even rely on Linux GlibC (GNU C library), so an application built with Golan can even run in old distributions.

Well, goto in this case is not that bad. Without goto the Linux code would be full of many nested if-else, what would lead to more bugs, as C lacks C++ RAAI (Resource-Acquisition-Is-Initialization) feature that allows usage of class destructors for executing actions at the end of scope such as releasing resources and deallocating memory. Besides Linux kernel, Goto is widely used on C programming for embedded systems for error handling, managing resources and creating finite state machines. It is possible to use RAAI in C, but only with GCC proprietary features that will make the code non portable to other C compilers.

In this article John Rehger makes the case for GOTO - https://blog.regehr.org/archives/894.

> But having used busybox utils on a daily basis I truly do not understand how people can use them daily and not go insane.

Busybox is meant to be used in embedded Linux systems, often found in routers, printers, cameras and etc. In those systems every megabyte of flash memory counts and every cost counts. Busybox (GPL license) encapsulates the whole non graphics userland in a single binary. An non-GPL alternative to it is Toybox which is used on Android since this tool has BSD license. Alpine distro was also designed for embedded systems, but it is now being used in containers due to the distro small footprint.

On mobile systems, the major concern is low power usage and battery duration, not performance, hence the dominance of ARM-based chips in this field. The great appeal of M1 chip is the performance and low battery power usage.

ARM is the Microsft of the semiconductor world. The company design and licenses CPU cores for several market segments, including: ARM cortex-M series cores intended for MCU - microcontrollers SOC (System-On-Chip); CPU-cores intended for embedded systems processors (MPU) such as ARM-Cortex-A series intended for embedded systems and mobile devices. And there are also ARM cores designed for servers, for instance A64FX Fujitsu chip that powers the Japanese supercomputer Fugaku, until now the fastest in the world. ARM cores highly customized with microarchitecture, such as Apple M1 and some Samsung ARM chips, are designed under architecture license.

A MCU is a self-contained chip containing up to 1MB of RAM, Flash memory up to 1 MB for the firmware; and several other peripherals such as digital IO, analog-to-digital converter, UART RS232 and so on. They are not comparable to Intel chips. MCUs are used in keyboards, mouses, car engine control unit, toys, home appliances and so on. The difference between the cores intended for MCUs and cores intended for MPUs is that cores for MPUs need external flash memory chips and external RAM memory. MPU chips and also they contains MMU - memory management unit for supporting virtual memory and operating systems that need this feature, such as iOS, Windows CE, Linux, BSD and etc.

The system calls are documented and backward compatible. However, Glib-C is only forward compatible, but not forward compatible. An application, built linking against an older version of Glibc than the one found at the deployment machine, is pretty likely to work on this machine, whereas the other way around will result on a linking error.

By using MUSL it is possible to build fully statically linked applications that works everywhere, however dlopen(), dlclose() calls, that are used for loading shared libraries and plugin at runtime on Unix-like systems, do not work with MUSL.

It seems that some functional programming languages are hard to sell to management due to the limited adoption, talent pool concerns and integration with existing systems and code. In the case of Clojure, despite being able to run in the JVM, Clojure has a unfamiliar lisp syntax to most Java developers and is dynamically typed which makes the life of IDEs harder since dynamically typed languages are hard to refactor, hard to figure out which types a function returns and so on. In the case of Scala, Kotlin seems to eating its launch due to be borned with full tooling support from Jetbrains and endorsement by Google on Android. In addition Kotlin is FP enough without over-engineering and compiles faster than Scala. Regarding the F# the problem might be that most tutorials about .NET platform are in C# and most codebases are in C# and Microsoft does not promote F# in the same extent as C#. Moreover C# is getting more in more functional features.

More and more languages are adding support functional-programming features, including Java, C#, Swift, D Language (DLang), Rust and also C++11, C++17 and C++20.

But C lacks even strings, lots of C bugs and vulnerabilities are related to memory management, memory ownership and string handling. Even the C subset of C++ is better than C since it at least has more explicit type conversions that forces the developer to state his or her intent. One example of the C string problem is the strcpy(buffer, char* string) that copies a string to a buffer. If an external actor discovers how to manipulate the string size, he or she can take advantage of this buffer overflow vulnerability and even execute arbitrary code remotely if it is used in a server. If the application with this problem is a file, one create a specially crafted file to take advantage of this design flaw.

However using C in the case of the original poster does not matter much as the application is game-related not subject to untrusted input.

Yep, but the installation is far simpler than the procedure for installing a Linux application not available at repositories or an application that uses unstable libraries likely to change the ABI. All one needs to install an MacOSX app-bundle is to drag and drop the .app folder or .dmg disk image to /Applications. MacOSX reads the plist metadata and finds the icon and the executable path, then renders the icon making easier and intuitive for non technical users to just click and run the application.

On Windows is easier to build self-contained applications as there is no the RPATH issue. All one needs to build a self-contained application that is easier to ship and works everywhere is just add shared libraries at the same directory where is the executable and create a zip archive or a MSI installer. When applications are installed, they are installed in a single folder and files are not scattered across the file systems like binaries in /usr/bin, /usr/local/bin, /libs/, /usr/shared, ..., as in Linux and other unices.

Well some "real engineers" really do code, but mostly not CRUD applications. Most embedded systems, industrial control systems and avionic software are designed and crafted by electronic/electrical engineers. High performance computing number crunching is also dominated by physicists and engineers that uses that for physics simulation, particle physics studies, aerospace design, CFD - Computational Fluid Simulation, FEM - Finite Element Methods and so on.

This case of MyBook seems to be another case of vulnerability caused by C. Actually most CVE vulnerabilities happens due programming mistakes that the C language makes easier to make such as to buffer overflow, out-of-bounds array access, undefined behaviour, use-after-free and etc.

Well the problem of Snaps is complex sandbox, lack of user control, forced updates and so on which is disliked on many non-Ubuntu distributions.

Flatpack attempts to solve the dependency hell problem by providing standard runtime, a set of libraries, Glib-C, Gtk or Qt with a fixed version which requires the developer to build an application linking against those runtime, which avoid binary compatibility problems and dependency hell. The trouble of Flatpacks is the integration with the desktop.

AppImage attempts to solve the dependency hell by bundling everything into a single launcher executable with a SquashFs file system image payload. The disadvantage of this approach is that it is only possible to use a single executable. AppImage are also not free from GlibC compatibility issues.

A MacOSx-like app bundle and a changing in Linux development culture to build and design applications as self-contained from inception would strength the Linux desktop and reduce the application packaging work duplication that still affects Linux distributions.

It is possible to write safe-C, but C is far more error prone than C++. C has more implicit type conversions than C++, which may results in bugs and undefined behaviours. C lacks RAII (Resource-Acquisition Is Initialization) that is useful for memory and resource management. C will actually require more code than C++ since, the C standard library lacks generic data structures such as vectors, hash maps, linked lists and so on. The implementation of those data structures requires lots of preprocessor macro hacks.

It is possible to write safe C, only if one uses static analysis tools and undefined behaviour sanitizers. In the case presented by the article, as it is related to game, safety does not matter much, unlike device drivers, operating systems or embedded systems where C bugs can introduce security vulnerabilities.

Regarding the compile-time complaint, it is possible to reduce the compile-time by using forward declarations; forward template declarations; template forced instantiation and isolating large parts of a project in a static library using CMake.

The reason may be that just like Mozilla Foundation, they may be tired of dealing with bugs such as buffer overflow, integer overflow, undefined behaviours and use-after-free which are responsible for most security vulnerabilities that still haunts C and C++.

If you are not afraid of unsafe blocks and extern "C" functions, it is possible to call a any C api directly including Win32 API for GUI graphical user interfaces. On Linux, one can call Gtk directly or call Qt through a custom C wrapper. The only problem is that both methods are not cross-platform. However, one with enough motivation can develop a cross-platform unified wrapper or interface that abstracts Gtk, X11 and/or Win32 API and MacOSX cocoa API.

Calling Qt5 widgets through a custom C-wrapper may be a better approach than reinventing the whell since Qt already abstracts Win32 API, Unix X11 (X Windows Systems), Unix-Wayland, and MacOSX Cocoa .

The whole problem is that Anbox is distributed as Snaps which is disliked by folks from many non Ubuntu-like Linux distributions. It would be interesting if there was a docker image with Anbox pre-installed that allowed playing with Android apps with zero configuration and setup.

It is possible to support a wide range of Linux distributions if one takes proper care such as: use CMake and never use GNU autotools or GNU Make as CMake has the best IDE support among C++ building systems; static link as much as possible avoiding reliance on the package manager for getting dependencies; set RPATH as relative path to executable in CMake building system for dependencies that cannot be statically linked; locate resource files using the relative path to the executable instead of relying on fixed path such as /usr/local, /usr/share, /etc/, ...; distributed the executable and the shared libraries in a zip or tar.gz archive with .desktop file containing an icon, so that the user can launch the application just clicking on it. Most MacOSX applications are already distributed in this way in the app-bundle format a, directory ending with suffix .app, containing, a p-list xml metadata, shared libraries and data. The app bundles can be installed just by dragging and dropping without worrying about dependency hell, enabling root permission and so on. The Linux fragmentation could decrease if Linux distros adopted a MacOSX-like standardized app-bundle format.

The last point of failure is the GlibC (GNU C library), a Linux application, even if fully statically linked against all dependencies or packaged with all shared libraries, may fail to run in another Linux distribution if it is using an older version of the GlibC than the one that the executable was linked against. Therefore, in order to ensure that the application can work in the broadest range of distributions, it is necessary to static link the application against the oldest possible version of GlibC or build the application on the LTS (Long Term Support) version of the supported distribution.

If one does not have enough resources to support Linux, an alternative approach, assuming that is OpenGL is used, may be building the executable for Windows and Wine using MinGW compiler either on Windows or by cross-compiling on Linux using Dockercross-mingw (https://github.com/dockcross/dockcross). At least with Wine, one will not have to deal with Glib-C compatibility issues.

Forking new processes is less efficient than spawning new threads as processes uses more machine resources and more memory. In addition, communication between threads is far more simple than communication between processes. Multicore may not be deal-breaker for server applications, but it matters for applications that require parallel processing.

At least Rust has far less building systems than C and C++ building system jungle: C, GNU Make, BSD Make, Windows Make, GNU autotools, and much more. Google may have a valid reason for not using Cargo, since they may need to integrate Rust with existing C and C++ code. It would be nice if Cargo had a way to build and link C and C++ dependencies in the same source tree as there are many C libraries which the functionality is still missing in Rust.

The flight software is actually a real-time (aka deterministic) embedded system software. And the control loop is the typical control loop found in embedded systems: 1 - read data from sensors through ADC (Analog-To-Digital Converters), I2C, SPI, CAN (Controller Area Network) and so on; 2 - compute the output to actuators, such as motors, hydraulic cylinders, valves, motors, lights and so on, using some control law and the current state; 3 - repeat the cycle. The algorithm that drives the output may be based on algorithms from control theory, namely state space model, PID control or Kalman filter. The computers that they may be using might be single-board computers based on ARM-core, MIPS-core, PowerPC or even X86 variant for embedded systems and/or lots of microcontrollers. Before the advent of computers, the control theory algorithms were implemented using "analog computers", which are specially designed analog circuits for computing differential equations.

Control theory algorithms can be developed using tools such as Matlab, Matlab-Simulink, Modelica or Scilab-Scicos (Open-Source) from Inria. Besides C or C++, another language used in embedded systems like that is Ada, which is much safer and reliable than both C and C++.

Modern browsers uses multi-process, a process for each tab due to security and reliability reasons. If a single tab crashes, the all other tabs will not be crashed. In addition, unlike threads, processes are isolated from each other since they do not share the same address space, which is another line of defense. This multi-process approach could not be needed if an entire web browser, such as Firefox, was written in a memory safe language like Rust.

It only soves the problem partially. The drawback of AppImage is that it cannot package an application containing multiple executables such as Emacs. The best solution may be coping Apples' app-bundle idea. An app-bundle is just a folder containing metadata, executables, shared libraries (dylibs), text files and images. This package format can be installed by just dragging and dropping the folder to /Applications directory and deleted by just removing the folder. The Finder file manager shows the app bundle as the application icon and allows running the app by clicking on the app-bundle folder. This idea is easy to implement on Linux, it would decrease Linux fragmentation and the work duplication that happens when packaging some application.