PHP loads all available functions into a giant hashset (see zend_disable_function in PHP's source). 'disable_functions' removes the functions from the hashset, making them unavailable to be called. Due to its interpreted nature, this indirection works much like a sandbox would.
I agree with this. As someone who took 3 degrees in computer science, one called "systems developer" and another called "software engineer", I can confidently say we have a taxonomy problem in computer science education.
It makes me crazy that companies labels there entire programmer workforce as "software engineers" when there are no engineering concepts involved at all. Other fields (medical, mechanical, civil engineering) are a lot more mature in this area and have solved this issue long ago.
The direct hooking into the narrow phase solver is the most performant way to go about it, but it does present several issues in state management. I did the same thing in Farseer Physics Engine, but also added high level events on bodies[1]. The extra abstraction makes it easier to work with, but due to the nature of delegates in C#, it was also quite a bit slower.
They could do with creating defaults for the narrow phase handler, buffer pool, threat dispatcher, etc. for devs who don't need extreme performance and just want a simple simulation.
The security of the Apple ecosystem is miles ahead of others. Every time I reverse engineer some component of their OS, it is very different from what I've seen before. I always find myself surprised by their thoughtfulness and engineering craft.
Recently I've taken on their code signing component. The concepts they've created, such as identifying applications by their "designated requirements" is a stroke of genius. It makes the system completely stateless and capable of almost anything without auxiliary data structure or additional code.
I've seen other engineering teams try and fail at building something similar, and never with such powerful simplicity.
The condition is called Anosmia and can stem from different sensor and brain conditions. It would be interesting to try the technique on people with these conditions to map the different kinds of olfactory failures.
If you get in contact with the researchers, please let us know how it went.
It is also kinda a self-burn. Chromium an aging code base [1]. It is written in a memory unsafe language (C++), calls hundreds of outdated & vulnerable libraries [2] and has hundreds of high severity vulnerabilities [3].
I generally agree. However, there are several important optimizations that Roslyn does not yet have. I love the improvements in newer versions of the compiler as much as the next guy, but historically, waiting 20 years on getting basic inlining, hoisting and SIMD accelerations has left many of us with the only option of not relying on C# for performance.
Taking a bunch of data from the Korean National Health Insurance database and looking for one specific connection is less than helpful. Like carl sagan said: extraordinary claims require extraordinary evidence.
A significant error I often see in cancer studies, is the assumption that after a carcinogenic event (consumption of something toxic, exposure to radiation, etc.) suddenly there is a tumor of such a large size the person notices it and gets it investigated by a medical professional.
Some cancers take years to grow, which means the increase in certain cancer-type rates cannot possibly be explained by a carcinogenic event within a 1-year timescale.
Science is not just about finding relationships in data. You have to justify the claims, argue against them, uncover biases and guarantee the correctness of data. Statistical links are the weakest form of evidence and literally anything can be proven if not graduated through the scientific model.
It looks like a process model; isolation between programs with a system for inter-process communication, and running within a single process's memory.
If I understand correctly, instead of writing a c++ application to offload the computation of something, and then build a way of communicating the result between processes, you create a Space, define it as JIT/AOT, managed/unmanaged and execute it and use the built-in communication for transfering data.
It is an interesting approach. The author should check out Unity's Burst compiler. It takes a chunk of C# code, AOT compile it with LLVM and then the main application can invoke it. The concepts are adjacent.
A few years ago i picked up the old (but famous) cases of Brad Cooper and Casey Anthony as they have tons of available digital forensics evidence.
I double-checked the forensics work and found several mistakes in processes, assumptions and technical conclusions. I sent off my findings to people associated with Project Innocence - not because I found anything that proved Cooper or Anthony's innocence, quite the opposite. Instead, I wanted to let them know that forensics experts can make mistakes.
It is interesting that scientific work have fault-finding processes like peer-reviews, but forensics investigations in court cases does not.
C# started as a language tightly aligned with C++/Java, but has since moved to be something else entirely that is highly capable.
I assume that free-floating functions are global functions. You can achieve something similar by "global using". Put this in a file and tug it away somewhere:
"global using static YourStaticClass;"
Now you can call all the static methods on the class everywhere.
As for the using vs. naming convention, most people use the IDE and hover the mouse over the type to see its identity. Once you get proficient with the IDE, you can do it using shortcuts. However, if you really want to prefix all types with a shorthand of the package it came from, you can do it with aliases in C#.