Nuclii

nuclii

On the seventh day, amidst the darkness, God granted ProjectDiscovery, aiding brave souls in their perilous pen-testing journey. In the wake of ProjectDiscovery's ascent, tools like Nuclei, Katana, Subfinder, Naabu, and the latest addition, cvemap, emerged to fortify the arsenal of the brave. CVEmap and Nuclei missing feature And most of the were disappointed by the missing feature to “map” results directly to existing nuclei templates. penetration testers cvemap This absolutely necessary feature does not exist today, and I hope it will change - I will create an issue on to address this problem. GitHub However, I decided to fix this problem in this guide myself because a solution might not come at all. Fortunately, the existing nuclei templates use the same naming convention as the CVE one, and nuclei support an argument where you can enter the ID of the desired templates directly into the input.  CVEmap’s flag  nicely informs that the template exists in the Nuclei, but unfortunately, it doesn't tell how and where to find it. -template By combining this information, I came up with an ugly but short solution. Solution A bit of allows us to create the following script. bash glue This script scans targets from a file, with Nuclei templates filtered based on criteria from cvemap. Command expansion ( ) creates the resulting list of template IDs, separated by a comma, which Nuclei accepts as valid template selection. targets.txt $(…) nuclei -l "targets.txt" \
       -id "$(cvemap -template -list-id -silent \
        -age '<365' -q '"remote code execution" is_remote:true' -vendor cisco |
        tr -s '\n' ',')" \
       -o "output.txt" Precisely, in this case, the command scans CVEs of the Cisco products that provide RCE to the attackers and are less than one year old. Isn't that great!? Feel free to change the query on line 3 for your purpose. The other lines are mandatory. Postface Why this feature doesn't exist officially, I don't know, but if I had to bet, it's because they want to use the synergy of these tools in their paid cloud platform, and they don't want to give all the features for free but at the same time they want to be opensource. So they created a flag with the flag, which informs you that the template exists, but which one it is, and so on, you must look up yourself. cvemap -template Resources https://docs.projectdiscovery.io/tools/cvemap/running https://cloud.projectdiscovery.io/?ref=api_key https://github.com/projectdiscovery/cvemap https://github.com/projectdiscovery/nuclei

The Pen-Tester's Arsenal: ProjectDiscovery's CVEmap to Nuclei Template Mapping

Worlds Within Worlds: The Story of Nuclear Energy, Volume 2 (of 3), by Isaac Asimov is part of HackerNoon’s Book Blog Post series. You can jump to any chapter in this book here . Volume II, THE STRUCTURE OF THE NUCLEUS: Protons in Nuclei Protons in Nuclei Let us, nevertheless, go on to describe some of the progress made in the 1920s in terms of the proton-electron theory that was then accepted. Since a nucleus is made up of a whole number of protons, its mass ought to be a whole number if the mass of a single proton is considered 1. (The presence of electrons would add some mass but in order to simplify matters, let us ignore that.) When isotopes were first discovered this indeed seemed to be so. However, Aston and his mass spectrometer kept measuring the mass of different nuclei more and more closely during the 1920s and found that they differed very slightly from whole numbers. Yet a fixed number of protons turned out to have different masses if they were first considered separately and then as part of a nucleus. Using modern standards, the mass of a proton is 1.007825. Twelve separate protons would have a total mass of twelve times that, or 12.0939. On the other hand, if the 12 protons are packed together into a carbon-12 nucleus, the mass is 12 so that the mass of the individual protons is 1.000000 apiece. What happens to this difference of 0.007825 between the proton in isolation and the proton as part of a carbon-12 nucleus? According to Einstein’s special theory of relativity, the missing mass would have to appear in the form of energy. If 12 hydrogen nuclei (protons) plus 6 electrons are packed 81together to form a carbon nucleus, a considerable quantity of energy would have to be given off. In general, Aston found that as one went on to more and more complicated nuclei, a larger fraction of the mass would have to appear as energy (though not in a perfectly regular way) until it reached a maximum in the neighborhood of iron. Iron-56, the most common of the iron isotopes, has a mass number of 55.9349. Each of its 56 protons, therefore, has a mass of 0.9988. For nuclei more complicated than those of iron, the protons in the nucleus begin to grow more massive again. Uranium-238 nuclei, for instance, have a mass of 238.0506, so that each of the 238 protons they contain has a mass of 1.0002. By 1927 Aston had made it clear that it is the middle elements in the neighborhood of iron that are most closely and economically packed. If a very massive nucleus is broken up into somewhat lighter nuclei, the proton packing would be tighter and some mass would be converted into energy. Similarly, if very light nuclei were joined together into somewhat more massive nuclei, some mass would be converted into energy. This demonstration that energy was released in any shift away from either extreme of the list of atoms according to atomic number fits the case of radioactivity, where very massive nuclei break down to somewhat less massive ones. Consider that uranium-238 gives up 8 alpha particles and 6 beta particles to become lead-206. The uranium-238 nucleus has a mass of 238.0506; each alpha particle has one of 4.0026 for a total of 32.0208; each beta particle has a mass of 0.00154 for a total of 0.00924; and the lead-206 nucleus has one of 205.9745. This means that the uranium-238 nucleus (mass: 238.0506) changes into 8 alpha particles, 6 beta particles, and a lead-206 nucleus (total mass: 238.0045). The starting 82mass is 0.0461 greater than the final mass and it is this missing mass that has been converted into energy and is responsible for the gamma rays and for the velocity with which alpha particles and beta particles are discharged. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Isaac Asimov. 2015. Worlds Within Worlds: The Story of Nuclear Energy, Volume 2 (of 3). Urbana, Illinois: Project Gutenberg. Retrieved May 2022 from https://www.gutenberg.org/files/49820/49820-h/49820-h.htm#c20 This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html .

The Story of Nuclear Energy, Volume 2 (of 3): Protons in Nuclei

Comparing AWS Lambda and Nuclio With serverless, you delegate the responsibility of running your infrastructure to a platform provider as much as possible. This frees your engineers to focus on building what your customers want from you — the features that differentiate your business from your competitors’. For this philosophy to work, however, the platform needs to not only give you the tools to build those features, but also deliver the performance that will keep engineers satisfied. Yes, services such as AWS Lambda are powerful, but they have a number of well-documented limitations that make them unsuitable for some workloads. These include: Cold starts and high latency make them unsuitable for real-time applications that require consistent and millisecond-level response times. The pay-per-invocation model makes them costly in high throughput scenarios. The event-driven model, coupled with a max execution time or data size restrictions, makes them unsuitable for long-running tasks or heavy data or AI processing. They are limited to triggers and event sources that are specific to the cloud provider. Enter , an open source serverless platform that is built on top of Kubernetes and comes in both managed platform-as-a-service (PaaS) and self-hosted flavors. In this post, we will compare Nuclio with AWS Lambda, see how Nuclio addresses the above limitations and explore the new use cases Nuclio is unlocking, such as: Nuclio High throughput data processing pipelines or ETL. Serving machine learning models in real time. Real-time applications such as multiplayer games. Long-running jobs and services. Nuclio vs. AWS Lambda Concurrency One of the biggest shifts from traditional application development to AWS Lambda is how concurrency is managed. An Express.js web application running in a container/VM can handle multiple requests concurrently. In other words, your application manages its own concurrency. You scale the application by increasing the number of concurrent requests it can handle (scaling up) and then increasing the number of containers (scaling out). With AWS Lambda, concurrency is managed by the platform, and a concurrent execution would process only one request at a time — much like an actor in the , which would process one message at a time. The application can scale out by increasing the number of concurrent executions of the function. actor model Lambda’s concurrency model has its advantages: It simplifies application development. Concurrency is a constant source of bugs and performance issues, as developers struggle with writing highly concurrent applications. It allows you to price each invocation individually because you don’t have resource contention from handling concurrent requests. This enables the pay-per-use pricing model and is one of the cornerstones of . findev Still, Lambda also has some disadvantages: You can’t make use of idle CPU cycles when a function is waiting on IO. Since most functions are IO-heavy, this results in significant inefficiencies. It requires more scaling, which means more cold starts. To handle X concurrent requests, you need X concurrent executions, which equates to X cold starts. This makes it nearly impossible to achieve predictable performance. Nuclio, on the other hand, can scale up as well as out. A function processor (analogous to a container) can host multiple function workers. Each worker is then able to process one message at a time. This system supports concurrency within the same processor, and then autoscales the number of replicas of the processor based on load. Figure 2: The architecture of a Nuclio function. Another interesting difference between Lambda and Nuclio is that Nuclio lets you specify both the minimum and maximum number of replicas. And as an aside, Nuclio also supports GPUs. Figure 3: Nuclio lets you configure both the minimum and maximum number of replicas. With Lambda, you can configure a reserved concurrency for a function, which (counterintuitively) sets its max concurrent executions. But there is no way to tell the system to always keep a certain number of concurrent executions running at all times. The system always scales to zero when there is no traffic — behavior that is highly undesirable for systems that experience regular spikes in traffic. For example, my employer, , is in the sports streaming business. We see huge spikes in traffic all the time, as millions of users flood in seconds before a sporting event starts. DAZN Figure 4: Sports streaming platforms, such as DAZN, experience huge spikes in traffic just before a sporting event kicks off. Without the ability to configure the minimum number of concurrent executions, these spikes result in large numbers of cold starts. Also, in these cases, Lambda has to scale out the number of concurrent executions quickly to meet the surge in demand. Here, we also run into the on how quickly Lambda is able to scale out. As such, we are currently not able to use Lambda on the critical path of our system, which has to shoulder these spikes. 500/minute limit With Nuclio, you can programmatically update the minimum replica count prior to the event so that when the spikes come, you don’t have to worry about hitting scaling limits or enduring the performance hit from cold starts. You can also tell Nuclio to scale to zero immediately via API calls, which saves resources. Figure 5: Adjusting the minimum number of replicas enables you to deal with predictable spikes in traffic. Timeout Another major difference between Lambda and Nuclio is how timeout is handled. With Lambda, an invocation can run for up to 15 minutes. While it’s possible for you to use or step functions to extend this limit, both approaches have their own problems. As such, Lambda functions are great for event-driven architectures and performing short, ephemeral tasks. recursive functions With Nuclio, there is no max execution time. The containers can keep on running, which in turn allows you to go beyond the constraints of the event-driven model. You can now turn a function into a long-running service, which unlocks some interesting use cases such as long-running ETL jobs and training machine learning (ML) models. Caching State Between Invocations Both Lambda and Nuclio functions accept an event and context during an invocation. Figure 6: Both Nuclio and Lambda functions accept an invocation event and context as arguments. With Lambda, the is ephemeral and does not persist between invocations. If you want to persist data between invocations (e.g. static configurations, database connections), then you need to declare them as global variables outside of the function handler. context object With Nuclio, the execution context itself is persisted between invocations and can be used to cache state. The context object also includes a built-in logger, which supports structured logging with JSON and four log levels: DEBUG, INFO, WARN and ERROR. You can configure the default log level for a function and can even override this default log level per invocation — which is very useful for debugging. You also have the ability to export your logs to external services such as Elasticsearch. Figure 7: With Nuclio, you can select the default log level for every function. Figure 8: You can also override the default log level for an invocation. In addition, there are hooks for performing context initialization, which is called before the first invocation on the function. This allows you to perform initialization logic before the container is put into active use and removes the dreaded cold start problem that Lambda suffers from. Data Volumes and Persistent Data Connections With Lambda, functions only run when they are triggered by events. Furthermore, concurrent executions are garbage-collected when they have been idle for a few minutes. This behavior makes life difficult when you are working with relational database management systems (RDBMS) and other systems that require persistent connections. Indeed, a has been developed to help you avoid the many pitfalls of using Lambda with RDBMS. Furthermore, Lambda doesn’t allow you to use persistent data in standard file system mounts, which forces you to copy to/from object storage before working on large files such as images, logs, ML models, etc. set of guidelines With Nuclio, however, you can use the to maintain persistent connections to databases. Since the context is maintained at the processor level, you get better reuse, as they are shared across invocations. You can also take care of other aspects of data-fetching with data bindings, including batching and caching, which helps improve IO performance of the application. Additionally, you can mount volumes to functions, which is useful for working with ML models or Tensorflow, and you can mount Kubernetes secrets as volumes. Indeed, Nuclio supports all of the that Kubernetes supports. context object volume types Runtimes Both Lambda and Nuclio support popular languages such as Go, Node.js, Python, .Net Core, Java and Ruby. Also, both platforms offer a way for you to customize the execution runtime. With Lambda, you can create a and distribute it through . This lets you introduce additional language runtimes that are not natively supported by the Lambda platform. Several vendors have published runtimes for PHP, Rust, Erlang and Elixir, to name a few. custom runtime AWS Lambda Layers With Nuclio, you can run functions on your own Docker image (see Figure 9), which can come from a private image repository. This allows you to tailor the execution environment itself. You can also support additional language runtimes through a Shell function, which allows you to handle invocation events with any executable binary. See for more details. this example Figure 9: Nuclio lets you run functions on top of your own Docker image, which can come from a private image repository. Triggers Lambda is supported by a . wide range of event sources Nuclio ships with , including cron, HTTP, Kafka, Kinesis and RabbitMQ. Since Nuclio is open source, you can also write your own trigger for services that you want to integrate with and leverage other people’s contributions. The HTTP trigger gives you an easy way to integrate Nuclio with other event sources that support HTTP as target, such as SNS. Also, since Nuclio supports the standard, it can arguably support many more event sources that are CloudEvents-compliant. 13 triggers CNCF CloudEvents Nuclio triggers are all normalized to the same Event object. This removes the need to understand the specific event signature for each event source, which is often confusing when working with Lambda. It also makes it easy to switch a function between different triggers. Built-In HTTP Trigger With Lambda, you need to use API Gateway to create an HTTP endpoint for your functions. API Gateway is a feature-rich service, but it’s also complicated and often costs more to run than the Lambda invocations themselves. It also adds another source of latency to your API, which, at the minimum, is around 5ms to 10ms, and it can overhead spike to more than 100ms. This cost and latency overhead make it unsuitable for applications with high throughput or hard real-time requirements. With Nuclio, every function gets a private HTTP interface by default. To expose the endpoint publicly, you need to specify an similar to API Gateway. However, unlike API Gateway, this HTTP trigger does not incur extra costs and has minimal latency overhead. HTTP trigger Figure 10: With Nuclio, every function gets a private HTTP interface by default. Unlocking New Use Cases with Nuclio As you can see from our comparison, Nuclio differs from Lambda in a number of important areas, such as its concurrency model and that it has no max execution time. This opens the door to a whole range of use cases. Let’s take a moment to look at a few. High-Throughput Data Processing Pipelines or APIs For a high-throughput API, the cost of both API Gateway and Lambda is drastically higher than an equivalent application running in containers. This cost discrepancy has . lead many to rewrite their applications Nuclio’s concurrency model makes more efficient use of available resources, which significantly reduces operational cost when running at scale. Functions have built-in HTTP interfaces so you also don’t need to pay for an expensive API Gateway service. The ability to mount a volume to your function also lets you read and write data to/from a mounted volume at high speed and enables building stateful applications. Again, you can’t do this with Lambda today, as it doesn’t allow you to attach (Amazon EFS) volumes to functions. Amazon Elastic File System These features make it economically feasible to run high-throughput and high-performance APIs on Nuclio functions. The same can also be said about high-throughput data processing pipelines that have to process multiple terabytes of data per hour. APIs with Predictable Spikes in Traffic Nuclio gives you the ability to configure a minimum number of replicas. This allows systems that experience predictable spikes in traffic to reserve sufficient resources ahead of time and avoid degrading the user experience when the spikes happen. Examples include food ordering services such as Just Eat or Deliveroo or sports streaming services such as DAZN. At the same time, Nuclio still lets you scale to zero by setting the minimum number of replicas to zero. It gives you the control to optimize for resource usage or latency, depending on the situation. Real-Time Applications Nuclio does not suffer from cold starts and is able to deliver consistent and sub-millisecond response times on invocations. This makes it a suitable solution for applications with a hard, real-time requirement such as multiplayer games and real-time bots. Serving Machine Learning Models in Real Time To serve ML models in real time, you need to have both strong and predictable API latency and the ability to load and work with ML models that often are large in size (GBs). Nuclio lets you attach Kubernetes volumes to your functions, and there are no size limits on these volumes. Combined with the performance characteristics, it’s possible to implement these demanding workloads with Nuclio functions. Nuclio also has native , and lets you automatically deploy Jupyter notebooks and ML models as Nuclio functions. integration with Jupyter Long-Running Jobs and Services Nuclio does not impose a max execution timeout on function invocations. This allows you to turn your functions into long-running services and perform long-running ETL jobs. Nuclio’s init_context() hook lets you create long-running services, such as an application that constantly reads off a Twitter feed (e.g. loads the TwythonStreamer with the context, which is polling an external service, versus becoming triggered by an event). Conclusion As we discussed, Nuclio is one of the few open source solutions that are also business-viable. It has key architectural advantages for higher performance or data-driven applications, including: Nuclio is cloud-agnostic. It can be used in multi-cloud/hybrid-cloud scenarios. You can also run Nuclio on a laptop using plain Docker, which makes debugging easier. Nuclio’s concurrency model and the ability to mount file volumes lets you build high-performance APIs and high-throughput data processing pipelines. Nuclio gives you greater control over the concurrency of your application, which makes it viable even for applications with very spiky traffic. Nuclio’s execution contexts are persisted between invocations, and it doesn’t impose a max execution time on invocations. This allows you to create long-running stateful applications such as ETL jobs. Nuclio lets you attach Kubernetes volumes to your functions and has no limitations on the size of the volume. This makes it possible for you to work with large ML models that often are GBs in size. Nuclio also has native integration with Jupyter and can automatically deploy your Jupyter notebooks and models as functions. Nuclio provides a good out-of-the-box developer experience. It has a built-in logger with structured logging support, and you can easily export your logs to an external log aggregation service. If you are looking for a serverless platform that is not tied to a specific cloud provider, Nuclio is worth a look. Hi, my name is . I’m an and the author of . I have run production workload at scale in AWS for nearly 10 years and I have been an architect or principal engineer with a variety of industries ranging from banking, e-commerce, sports streaming to mobile gaming. I currently work as an independent consultant focused on AWS and serverless. Yan Cui AWS Serverless Hero Production-Ready Serverless You can contact me via , and . Email Twitter LinkedIn Come learn about operational for AWS Lambda: CI/CD, testing & debugging functions locally, logging, monitoring, distributed tracing, canary deployments, config management, authentication & authorization, VPC, security, error handling, and more. BEST PRACTICES You can also get off the face price with the code . 40% ytcui Get your copy . here Originally published at theburningmonk.com on April 4, 2019.

Comparing Nuclio and AWS Lambda

We’ve gotten used to there always being a trade-off: if something is abstract and easy to use as , it’s probably slow and inflexible. Either that, or we’ve had to squeeze maximum performance and address unique application requirements at the expense of usability. But nuclio’s serverless functions ( ) lets us rapidly create and run code without an infrastructure hassle. nuclio runs faster than bare-metal code, addresses a broader set of applications, is simpler to debug and most importantly, it runs ANYWHERE. serverless https://github.com/nuclio/nuclio A while ago iguazio needed a way to add elastic and ad hoc data processing capabilities in its real-time data platform, so we developed a high-speed FaaS layer for this. We then took what we learned from the first generation and built a unique serverless platform. We call it : open-source nuclio Delivering real-time performance and maximum parallelism Enabling simple debugging, regression and a multi-versioned CI/CD pipeline Supporting pluggable data/event sources with common APIs Portable across low-power devices, laptops, on-prem and public cloud Read more on serverless background and current challenges in my post nuclio’s Architecture nuclio’s core component is the function processor (written in Go). This processor works through abstract interfaces and is the function’s “OS,” providing all access to events, data, logs and so forth. The same function code can be fed from a variety of pluggable event sources (currently supporting HTTP, , , , , , and emulators). Kinesis Kafka RabbitMQ MQTT NATS iguazio’s V3IO, nuclio’s function processor architecture External data (objects, files, databases and streams) is accessed through a data binding interface which takes care of all data connection, security and caching aspects. We can write a function that will use local files, or access remote data over HTTP, or an extremely fast scale-out DB/stream over TCP or RDMA without changing the code. The nuclio processor is REAL-TIME. Access to its “OS” events and data is done with parallelism in mind, zero-copy, smart memory/thread reuse and non-blocking IO. Writing your own bare metal function will likely be slower than running it in the nuclio processor ecosystem. A single nuclio function processor can run 400,000 function invocations per second with a simple Go function or up to 70,000 events per secound using Python (PyPy) or node.js and respond in less than 0.1ms latency. That’s 100x faster than most serverless/FaaS solutions. Access between the Go-based processor and other language runtimes is done through low-latency shared memory access to eliminate context switches or process start overhead. nuclio supports four application modes: sync, async, stream and batch/interactive jobs, and dynamically distributes events, streams and job tasks among processors (the dealer). These make serverless applicable to new workloads including heavyweight backend and analytics tasks. nuclio platform services nuclio focuses on portability and reusability: Works in low-power devices, , Kubernetes, or inside an IDE using nuclio SDK Docker Events/data sources map to functions or versions/tags at deployment time Logs and statistics can be sent to multiple destination types, or to the IDE screen. Function images are stored in a shared repository and pushed to multiple clusters/devices Portability allows users to test and debug functions on their laptops with the SDK or Docker, ship them to run on Kubernetes clusters in different clouds, or push them down to multiple edge IoT devices. It also simplifies regression testing and diagnostics: functions feed from emulated events and write the output to a structured log that is compared against expected results; they’re promoted to beta if they pass automatically. Get started with nuclio in 60 seconds Deploying a full Kubernetes cluster or a bunch of services isn’t required to get started, just test drive nuclio with the all-in-one Docker version. Type the following in Linux (assuming Docker is installed): docker run -p 8070:8070 -v /var/run/docker.sock:/var/run/docker.sock -v /tmp:/tmp nuclio/playground:stable-amd64 -then open a browser at this address HTTP://<machine-ip>:8070 to see the nuclio playground UI. nuclio’s playground comes with a few built-in examples that explain how to write functions, use logs and add package dependencies through inline comments or defined events. To get started, select an example from the drop-down list, edit and rename it, and then push deploy. Build errors will show in the log, fix them and re-deploy. Once you’re done, use the invoke tab to generate manual events and test the function. Use the log level selector to change verbosity on the fly and debug problems. Note that under the hood, nuclio generated Docker containers or Kubernetes deployments from your function. You can develop nuclio functions using your favorite IDE, import or clone the and see the README or examples. Look at nuclio’s or To learn more, we go over its architecture there, as well as provide details about usage and . Can also get help in nuclio . nuclio-SDK official web site Github documentation CLI slack channel nuclio is still under development, it supports Golang, Python, and Node.js with Java coming soon. Give it a star and join us to accelerate the development of new features.

nuclio: The New Serverless Superhero

Author:
(1) K. Razi Naqvi, Department of Physics, Norwegian University of Science and Technology (NTNU), 7094 Trondheim, Norway Table of Links Abstract and 1 Introduction 2 Preliminary material 3 Comments elicited by the solution to Milne’s problem for B-particles 4 Flux to a spherical trap 5 Molecular motion in liquids 6 Concluding remarks and References 5 Molecular motion in liquids One of the most important and keenly controverted issues dicussed by Hildebrand in his thoughtful and purposely provocative note is the question whether concepts borrowed from the kinetic theory of gases or classical hydrodynamics can be legitimately applied to describe solute diffusion in liquid [30]. The bulk of his criticism is to be found in the last two paragraphs, excerpts from which appear below: Attempts to calculate absolute values of diffusivity have been made by starting from Stokes’ law for a particle settling under the pull of gravity, and extrapolating over the long path to a molecule participating with its neighbors in aimless thermal motions that are never as long as the molecular diameter. Individual molecules are not impelled by a vector force that can serve to measure a “coefficient of friction.” Any such coefficient is fictitious. If molecules were hard spheres, instead of electron clouds with imbedded nuclei, and were sufficiently far apart to justify speaking of binary collisions with linear free paths between them, the probable distance they could be expected to wander from their initial positions could be computed by the formula for a “random walk.” But polyatomic molecules that move less than 10 percent of their diameter require a more sophisticated mathematical formulation. They are in a continual state of soft, slow collision, with constant exchange between translational and internal energy. The random walk in this case is a slow, tipsy reel, without sudden changes of direction. The mathematical problem involved . . . If one is content with the macroscopic description provided by the DE, concepts such as the mean free path and friction coefficient do indeed recede into the background, but not until we have derived a satisfactory boundary condition. If one wants to ascertain the validity of the macroscopic equations, for example the boundary condition for a particular problem, one is obliged to take a microscopic look. Whether one uses the LBE (which speaks of trajectories between separable collisions) or the KKE (which envisages a medium with a given friction coefficient) for delimiting the domain of validity of the macroscopic description is quite immaterial, so long as one can convince oneself that one’s conclusion does not rest on some idiosyncracy of the model; the means would justify the end provided that the end can be reached by some other means as well. This paper is available on arxiv under CC BY 4.0 DEED license. Author: (1) K. Razi Naqvi, Department of Physics, Norwegian University of Science and Technology (NTNU), 7094 Trondheim, Norway Author: Author: (1) K. Razi Naqvi, Department of Physics, Norwegian University of Science and Technology (NTNU), 7094 Trondheim, Norway Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Preliminary material 2 Preliminary material 3 Comments elicited by the solution to Milne’s problem for B-particles 3 Comments elicited by the solution to Milne’s problem for B-particles 4 Flux to a spherical trap 4 Flux to a spherical trap 5 Molecular motion in liquids 5 Molecular motion in liquids 6 Concluding remarks and References 6 Concluding remarks and References 5 Molecular motion in liquids One of the most important and keenly controverted issues dicussed by Hildebrand in his thoughtful and purposely provocative note is the question whether concepts borrowed from the kinetic theory of gases or classical hydrodynamics can be legitimately applied to describe solute diffusion in liquid [30]. The bulk of his criticism is to be found in the last two paragraphs, excerpts from which appear below: Attempts to calculate absolute values of diffusivity have been made by starting from Stokes’ law for a particle settling under the pull of gravity, and extrapolating over the long path to a molecule participating with its neighbors in aimless thermal motions that are never as long as the molecular diameter. Individual molecules are not impelled by a vector force that can serve to measure a “coefficient of friction.” Any such coefficient is fictitious. If molecules were hard spheres, instead of electron clouds with imbedded nuclei, and were sufficiently far apart to justify speaking of binary collisions with linear free paths between them, the probable distance they could be expected to wander from their initial positions could be computed by the formula for a “random walk.” But polyatomic molecules that move less than 10 percent of their diameter require a more sophisticated mathematical formulation. They are in a continual state of soft, slow collision, with constant exchange between translational and internal energy. The random walk in this case is a slow, tipsy reel, without sudden changes of direction. The mathematical problem involved . . . If one is content with the macroscopic description provided by the DE, concepts such as the mean free path and friction coefficient do indeed recede into the background, but not until we have derived a satisfactory boundary condition. If one wants to ascertain the validity of the macroscopic equations, for example the boundary condition for a particular problem, one is obliged to take a microscopic look. Whether one uses the LBE (which speaks of trajectories between separable collisions) or the KKE (which envisages a medium with a given friction coefficient) for delimiting the domain of validity of the macroscopic description is quite immaterial, so long as one can convince oneself that one’s conclusion does not rest on some idiosyncracy of the model; the means would justify the end provided that the end can be reached by some other means as well. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Revisiting Discrepancies in Diffusion Theory: Molecular Motion in Liquids 

Boost Your Productivity With These 18 Developer Tools 🚀🔥

এই 18টি ডেভেলপার টুল 🚀🔥 দিয়ে আপনার উৎপাদনশীলতা বাড়ান

Steigern Sie Ihre Produktivität mit diesen 18 Entwicklertools 🚀🔥

Aumente su productividad con estas 18 herramientas para desarrolladores 🚀🔥

Boostez votre productivité avec ces 18 outils de développement 🚀🔥

इन 18 डेवलपर टूल के साथ अपनी उत्पादकता बढ़ाएँ 🚀🔥

18 種類の開発者ツールで生産性を向上しましょう 🚀🔥

이 18가지 개발자 도구로 생산성을 높이세요 🚀🔥

Aumente sua produtividade com estas 18 ferramentas para desenvolvedores 🚀🔥

Повысьте свою производительность с помощью этих 18 инструментов разработчика 🚀🔥

Bu 18 Geliştirici Aracıyla Üretkenliğinizi Artırın 🚀🔥

Tăng năng suất của bạn với 18 công cụ dành cho nhà phát triển này 🚀🔥

使用这 18 种开发工具来提高你的工作效率 🚀🔥

AI Sentience: How Neural Correlates Setback Consciousness Research

Unlocking the Secrets of Autocatalytic Sets: How Bit Strings and Reactions Shape Molecular Evolution

OpenCitations Meta: Conclusion, Acknowledgements, and References

OpenCitations Meta: উপসংহার, স্বীকৃতি, এবং রেফারেন্স

OpenCitations Meta: Schlussfolgerung, Danksagungen und Referenzen

Meta de OpenCitations: conclusión, agradecimientos y referencias

Méta OpenCitations : conclusion, remerciements et références

ओपनसाइटेशन्स मेटा: निष्कर्ष, आभार और संदर्भ

OpenCitations Meta: 結論、謝辞、参考文献

OpenCitations Meta: 결론, 감사의 말, 참고 문헌

OpenCitations Meta: Conclusão, Agradecimentos e Referências

Мета OpenCitations: заключение, благодарности и ссылки

OpenCitations Meta: Sonuç, Teşekkür ve Referanslar

OpenCites Meta: Kết luận, Lời cảm ơn và Tài liệu tham khảo

OpenCitations Meta：结论、致谢和参考文献

Science Versus Art In Our Exploration Of This World

Stories, News & Mentions about NUCLII

Nuclii’s Stories on HackerNoon