Twenty five years ago, The Big Lebowski blew into theaters like a tumbleweed on an empty street.

Domestic audiences barely showed up, with the comedic detective tale only earning $18 million. Audiences gave it a B CinemaScore. Critics sniffed that it wasn’t as good as Joel and Ethan Coen’s last release, the Oscar-winning Fargo.

But that was just, like, their opinion, man.

“I thought it was going to be a big hit,” star Jeff Bridges tells THR, along with sharing some of his personal behind-the-scenes photos from the film’s set, many of which appeared in his 2003 book, Pictures. “I was surprised when it didn’t get much recognition. People didn’t get it, or something.”

Comprehensions are a fantastic language feature in Python. They are an elegant alternative to manually constructing and populating data structures. Comprehensions are declarative – they just say what they are, as opposed to the implicit logic of manual looping. When it comes to simple object creation, comprehension should be used whenever possible. This goes not just for lists, but also for dictionaries and sets.

However, a widely perceived drawback to comprehensions is that they are harder to debug. When something goes wrong with a manual loop, the first thing to do is to print out the iterated values as they turn up. But the values of a list comprehension can’t be accessed, so print-debugging isn’t possible. To deal with this, it’s common to unravel the comprehension into a manual loop. Manual loops are uglier and more complicated and more error-prone than comprehensions, but that’s the price that must be paid for debuggability.

Cycling is one of the most sustainable modes of transportation. Increased ridership reduces fossil fuel consumption and pollution, saves space, and improves public health and safety. However, the bicycle itself has managed to elude environmental critique. Studies that calculate the environmental impact of cycling almost always compare it to driving, with predictable results: the bicycle is more sustainable than the car. Such research may encourage people to cycle more often but doesn't encourage manufacturers to make their bicycles as sustainable as possible.

Over many centuries, man’s obsession with time has led to increasing accurate ways to measure it. As the precision of techniques and instruments has increased over the years, so the units used to define time have become ever smaller.

The minute and the second have given way to the SI units of the millisecond, the microsecond, the nanosecond, the picosecond, and the femtosecond, which is the the length of time that light takes to travel the diameter of a virus.

Large Language Models (LLM) are on fire, capturing public attention by their ability to provide seemingly impressive completions to user prompts (NYT coverage). They are a delicate combination of a radically simplistic algorithm with massive amounts of data and computing power. They are trained by playing a guess-the-next-word game with itself over and over again. Each time, the model looks at a partial sentence and guesses the following word. If it makes it correctly, it will update its parameters to reinforce its confidence; otherwise, it will learn from the error and give a better guess next time.

Projects are fraught with uncertainty, so it is no surprise that the language and tools of probability are making their way into project management practice. A good example of this is the use of Monte Carlo methods to estimate project variables. Such tools enable the project manager to present estimates in terms of probabilities (e.g. there’s a 90% chance that a project will finish on time) rather than illusory certainties. Now, it often happens that we want to find the probability of an event occurring given that another event has occurred. For example, one might want to find the probability that a project will finish on time given that a major scope change has already occurred. Such conditional probabilities, as they are referred to in statistics, can be evaluated using Bayes Theorem. This post is a discussion of Bayes Theorem using an example from project management.

A vast collection of security tools

A collection of CSS3 powered hover effects to be applied to links, buttons, logos, SVG, featured images and so on. Easily apply to your own elements, modify or just use for inspiration. Available in CSS, Sass, and LESS.

There is an area of Python that many developers have problems with. This is an area that has seen many different solutions pop up over the years, with many different opinions, wars, and attempts to solve it. Many have complained about the packaging ecosystem and tools making their lives harder. Many beginners are confused about virtual environments. But does it have to be this way? Are the current solutions to packaging problems any good? And is the organization behind most of the packaging tools and standards part of the problem itself?

Join me on a journey through packaging in Python and elsewhere. We’ll start by describing the classic packaging stack (involving setuptools and friends), the scientific stack (with conda), and some of the modern/alternate tools, such as Pipenv, Poetry, Hatch, or PDM. We’ll also look at some examples of packaging and dependency-related workflows seen elsewhere (Node.js and .NET). We’ll also take a glimpse at a possible future (with a venv-less workflow with PDM), and see if the PyPA agrees with the vision and insights of eight thousand users.

“What happens when you open a web browser and enter google.com?” Many of us recall being asked this question before. I think it leaves an impression because navigating web pages is this magical process that we take for granted. We do it hundreds, if not thousands of times per day without knowing how it works. Most developers and engineers can explain parts of it, but the depth at which you can discuss this question is infinite.

Today, we’ll discuss the details of something else we take for granted: the terminal. What happens when you open a terminal emulator and enter “ls”? Like with browsers, there is too much content to fit into one blog post. We’ll give you what we think are the interesting details.

As I type these words, a mass exodus is underway from Twitter and Facebook. After decades of eye-popping growth, these social media sites are contracting at an alarming rate.

In some ways, this shouldn’t surprise us. All the social networks that preceded the current generation experienced this pattern: SixDegrees, Friendster, MySpace, and Bebo all exploded onto the scene. One day, they were sparsely populated fringe services, the next day, every­one you knew was using them and you had to sign up to stay in touch. Then, just as quickly, they imploded, turning into ghost towns, then punchlines, then forgotten ruins.

Artificial intelligence has made tremendous advances since its inception about seventy years ago. Self-driving cars, programs beating experts at complex games, and smart robots capable of assisting people that need care are just some among the successful examples of machine intelligence. This kind of progress might entice us to envision a society populated by autonomous robots capable of performing the same tasks humans do in the near future. This prospect seems limited only by the power and complexity of current computational devices, which is improving fast. However, there are several significant obstacles on this path. General intelligence involves situational reasoning, taking perspectives, choosing goals, and an ability to deal with ambiguous information. We observe that all of these characteristics are connected to the ability of identifying and exploiting new affordances—opportunities (or impediments) on the path of an agent to achieve its goals. A general example of an affordance is the use of an object in the hands of an agent. We show that it is impossible to predefine a list of such uses. Therefore, they cannot be treated algorithmically. This means that “AI agents” and organisms differ in their ability to leverage new affordances. Only organisms can do this. This implies that true AGI is not achievable in the current algorithmic frame of AI research. It also has important consequences for the theory of evolution. We argue that organismic agency is strictly required for truly open-ended evolution through radical emergence. We discuss the diverse ramifications of this argument, not only in AI research and evolution, but also for the philosophy of science.

The art of good programming depends upon the discipline of the programmer, no matter what language is being used. The purpose of object oriented programming (OOP) is to produce well designed reusable code. In principle OOP can be done in any language, even assembly. This is because all OO language compilers/assemblers (e.g. C++) ultimately translate the high level constructs of the language into machine language. Thus there is a mapping from an object oriented semantics onto the instruction and data arrays that are executable images.

Here we will present a design and implementation method for producing OO code in the C language. It turns out that using this methodology will strongly improve your overall program design and implementation just as you expect when programming in a native OO language like Java or C++. When working in C, however, the discipline applied to producing good designs comes from the programmer and not from the language itself.

A curated list of awesome Open-Source Intelligence (OSINT) Resources - GitHub - ARPSyndicate/awesome-intelligence: A curated list of awesome Open-Source Intelligence (OSINT) Resources