{"format": "qa", "instruction": "Why is conditional processing of a sorted array faster than of an unsorted array? In this C++ code, sorting the data ( before the timed region) makes the primary loop ~6x faster: #include include include int main() { // Generate data const unsigned arraySize = 32768; int data[arraySize]; for (unsigned c = 0; c < arraySize; ++c) data[c] = std::rand() % 256; // !!! With this, the next loop runs faster. std::sort(data, data + arraySize); // Test clock_t start = clock(); long long sum = 0; for (unsigned i = 0; i < 100000; ++i) { for (unsigned c = 0; c < arraySize; ++c) { // Primary loop. if (data[c] >= 128) sum += data[c]; } } double elapsedTime = static_cast (clock()-start) / CLOCKS_PER_SEC; std::cout << elapsedTime << '\\n'; std::cout << \"sum = \" << sum << '\\n'; } Without std::sort(data, data + arraySize); , the code runs in 11.54 seconds. With the sorted data, the code runs in 1.93 seconds. (Sorting itself takes more time than this one pass over the array, so it's not actually worth doing if we needed to calculate this for an unknown array.) Initially, I thought this might be just a language or compiler anomaly, so I tried Java: import java.util.Arrays; import java.util.Random; public class Main { public static void main(String[] args) { // Generate data int arraySize = 32768; int data[] = new int[arraySize]; Random rnd = new Random(0); for (int c = 0; c < arraySize; ++c) data[c] = rnd.nextInt() % 256; // !!! With this, the next loop runs faster Arrays.sort(data); // Test long start = System.nanoTime(); long sum = 0; for (int i = 0; i < 100000; ++i) { for (int c = 0; c < arraySize; ++c) { // Primary loop. if (data[c] >= 128) sum += data[c]; } } System.out.println((System.nanoTime() - start) / 1000000000.0); System.out.println(\"sum = \" + sum); } } With a similar but less extreme result. My first thought was that sorting brings the data into the cache , but that's silly because the array was just generated. What is going on? Why is processing a sorted array faster than…", "input": "", "output": "You are a victim of branch prediction fail. What is Branch Prediction? Consider a railroad junction: Image by Mecanismo, via Wikimedia Commons. Used under the CC-By-SA 3.0 license. Now for the sake of argument, suppose this is back in the 1800s - before long-distance or radio communication. You are a blind operator of a junction and you hear a train coming. You have no idea which way it is supposed to go. You stop the train to ask the driver which direction they want. And then you set the switch appropriately. Trains are heavy and have a lot of inertia, so they take forever to start up and slow down. Is there a better way? You guess which direction the train will go! If you guessed right, it continues on. If you guessed wrong, the driver will stop, back up, and yell at you to flip the switch. Then it can restart down the other path. If you guess right every time , the train will never have to stop. If you guess wrong too often , the train will spend a lot of time stopping, backing up, and restarting. Consider an if-statement: At the processor level, it is a branch instruction: = 128) compiles into a jump-if-less-than processor instruction.\" /> You are a processor and you see a branch. You have no idea which way it will go. What do you do? You halt execution and wait until the previous instructions are complete. Then you continue down the correct path. Modern processors are complicated and have long pipelines. This means they take forever to \"warm up\" and \"slow down\". Is there a better way? You guess which direction the branch will go! If you guessed right, you continue executing. If you guessed wrong, you need to flush the pipeline and roll back to the branch. Then you can restart down the other path. If you guess right every time , the execution will never have to stop. If you guess wrong too often , you spend a lot of time stalling, rolling back, and restarting. This is branch prediction. I admit it's not the best analogy since the train could just signal the direction with a flag. But in computers, the processor doesn't know which direction a branch will go until the last moment. How would you strategically guess to minimize the number of times that the train must back up and go down the other path? You look at the past history! If the train goes left 99% of the time, then you guess left. If it alternates, then you alternate your guesses. If it goes one way every three times, you guess the same... In other words, you try to identify a pattern and follow it. This is more or less how branch predictors work. Most applications have well-behaved branches. Therefore, modern branch predictors will typically achieve >90% hit rates. But when faced with unpredictable branches with no recognizable patterns, branch predictors are virtually useless. Further reading: \"Branch predictor\" article on Wikipedia . As hinted from above, the culprit is this if-statement: if (data[c] >= 128) sum += data[c]; Notice that the data is evenly distributed between 0 and 255. When the data is sorted, roughly the first half of the iterations will not enter the if-statement. After that, they will all enter the if-statement. This is very friendly to the branch predictor since the branch consecutively goes the same direction many times. Even a simple saturating counter will correctly predict the branch except for the few iterations after it switches direction. Quick visualization: T = branch taken N = branch not taken data[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ... branch = N N N N N ... N N T T T ... T T T ... = NNNNNNNNNNNN ... NNNNNNNTTTTTTTTT ... TTTTTTTTTT (easy to predict) However, when the data is completely random, the branch predictor is rendered useless, because it can't predict random data. Thus there will probably be around 50% misprediction (no better than random guessing). data[] = 226, 185, 125, 158, 198, 144, 217, 79, 202, 118, 14, 150, 177, 182, ... branch = T, T, N, T, T, T, T, N, T, N, N, T, T, T ... =…", "metadata": {"source": "stackexchange:stackoverflow", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.419, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.419}}
{"format": "qa", "instruction": "How do I undo the most recent local commits in Git? I accidentally committed the wrong files to Git but haven't pushed the commit to the server yet. How do I undo those commits from the local repository?", "input": "", "output": "Undo a commit & redo $ git commit -m \"Something terribly misguided\" # (0: Your Accident) $ git reset HEAD~ # (1) If you just want to undo the commit, stop here!. [ edit files as necessary ] # (2) $ git add . # (3) $ git commit -c ORIG_HEAD # (4) git reset is the command responsible for the undo . It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. You'll need to add them again before you can commit them again. Make corrections to working tree files. git add anything that you want to include in your new commit. Commit the changes, reusing the old commit message. reset copied the old head to .git/ORIG_HEAD ; commit with -c ORIG_HEAD will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the -C option. Alternatively, to edit the previous commit (or just its commit message) , origin/bugfix Already up-to-date. How do I properly delete the remotes/origin/bugfix branch both locally and remotely?", "input": "", "output": "Executive Summary git push -d # Delete remote git branch -d # Delete local Note: In most cases, will be origin . Delete Local Branch To delete the local branch, use one of the following: git branch -d git branch -D The -d option is an alias for --delete , which only deletes the branch if it has already been fully merged in its upstream branch. The -D option is an alias for --delete --force , which deletes the branch \"irrespective of its merged status.\" [Source: man git-branch ] As of Git v2.3 , git branch -d (delete) learned to honor the -f (force) flag. You will receive an error if you try to delete the currently selected branch. Delete Remote Branch As of Git v1.7.0 , you can delete a remote branch using $ git push --delete which might be easier to remember than $ git push : which was added in Git v1.5.0 \"to delete a remote branch or a tag.\" Starting with Git v2.8.0 , you can also use git push with the -d option as an alias for --delete . Therefore, the version of Git you have installed will dictate whether you need to use the easier or harder syntax. Delete Remote Branch [Original Answer from 5-Jan-2010] From Chapter 3 of Pro Git by Scott Chacon: Deleting Remote Branches Suppose you’re done with a remote branch — say, you and your collaborators are finished with a feature and have merged it into your remote’s main branch (or whatever branch your stable code-line is in). You can delete a remote branch using the rather obtuse syntax git push [remotename] :[branch] . If you want to delete your serverfix branch from the server, you run the following: $ git push origin :serverfix To git@github.com:schacon/simplegit.git - [deleted] serverfix Boom. No more branches on your server. You may want to dog-ear this page, because you’ll need that command, and you’ll likely forget the syntax. A way to remember this command is by recalling the git push [remotename] [localbranch]:[remotebranch] syntax that we went over a bit earlier. If you leave off the [localbranch] portion, then you’re basically saying, “Take nothing on my side and make it be [remotebranch] .” I ran git push origin :bugfix , and it worked beautifully. Scott Chacon was right—I will want to dog-ear that page (or virtually dog ear-by answering this on Stack Overflow). Fetch changes Finally, execute the following on other machines to propagate changes: # Fetch changes from all remotes and locally delete remote deleted branches/tags etc --prune will do the job :-; git fetch --all --prune", "metadata": {"source": "stackexchange:stackoverflow", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.447, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.447}}
{"format": "qa", "instruction": "What is the difference between 'git pull' and 'git fetch'? What are the differences between git pull and git fetch ?", "input": "", "output": "In the simplest terms, git pull does a git fetch followed by a git merge . git fetch updates your remote-tracking branches under refs/remotes/ / . This operation is safe to run at any time since it never changes any of your local branches under refs/heads . git pull brings a local branch up-to-date with its remote version, while also updating your other remote-tracking branches. From the Git documentation for git pull : git pull runs git fetch with the given parameters and then depending on configuration options or command line flags, will call either git rebase or git merge to reconcile diverging branches.", "metadata": {"source": "stackexchange:stackoverflow", "category": "code", "subcategory": "python", "language": "en", "difficulty": "easy", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "qa", "instruction": "What does the \"yield\" keyword do in Python? What functionality does the yield keyword in Python provide? For example, I'm trying to understand this code 1 : def _get_child_candidates(self, distance, min_dist, max_dist): if self._leftchild and distance - max_dist < self._median: yield self._leftchild if self._rightchild and distance + max_dist >= self._median: yield self._rightchild And this is the caller: result, candidates = [], [self] while candidates: node = candidates.pop() distance = node._get_dist(obj) if distance <= max_dist and distance >= min_dist: result.extend(node._values) candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) return result What happens when the method _get_child_candidates is called? Is a list returned? A single element? Is it called again? When will subsequent calls stop? 1. This piece of code was written by Jochen Schulz (jrschulz), who made a great Python library for metric spaces. This is the link to the complete source: Module mspace .", "input": "", "output": "To understand what yield does, you must understand what generators are. And before you can understand generators, you must understand iterables . Iterables When you create a list, you can read its items one by one. Reading its items one by one is called iteration: >>> mylist = [1, 2, 3] >>> for i in mylist: ... print(i) 1 2 3 mylist is an iterable . When you use a list comprehension, you create a list, and so an iterable: >>> mylist = [xx for x in range(3)] >>> for i in mylist: ... print(i) 0 1 4 Everything you can use \" for... in... \" on is an iterable; lists , strings , files... These iterables are handy because you can read them as much as you wish, but you store all the values in memory and this is not always what you want when you have a lot of values. Generators Generators are iterators , a kind of iterable you can only iterate over once . Generators do not store all the values in memory, they generate the values on the fly : >>> mygenerator = (xx for x in range(3)) >>> for i in mygenerator: ... print(i) 0 1 4 It is just the same except you used () instead of [] . BUT, you cannot perform for i in mygenerator a second time since generators can only be used once: they calculate 0, then forget about it and calculate 1, and end after calculating 4, one by one. Yield yield is a keyword that is used like return , except the function will return a generator. >>> def create_generator(): ... mylist = range(3) ... for i in mylist: ... yield i*i ... >>> mygenerator = create_generator() # create a generator >>> print(mygenerator) # mygenerator is an object! >>> for i in mygenerator: ... print(i) 0 1 4 Here it's a useless example, but it's handy when you know your function will return a huge set of values that you will only need to read once. To master yield , you must understand that when you call the function, the code you have written in the function body does not run. The function only returns the generator object, this is a bit tricky. Then, your code will continue from where it left off each time for uses the generator. Now the hard part: The first time the for calls the generator object created from your function, it will run the code in your function from the beginning until it hits yield , then it'll return the first value of the loop. Then, each subsequent call will run another iteration of the loop you have written in the function and return the next value. This will continue until the generator is considered empty, which happens when the function runs without hitting yield . That can be because the loop has come to an end, or because you no longer satisfy an \"if/else\" . Your code explained Generator: # Here you create the method of the node object that will return the generator def _get_child_candidates(self, distance, min_dist, max_dist): # Here is the code that will be called each time you use the generator object: # If there is still a child of the node object on its left # AND if the distance is ok, return the next child if self._leftchild and distance - max_dist < self._median: yield self._leftchild # If there is still a child of the node object on its right # AND if the distance is ok, return the next child if self._rightchild and distance + max_dist >= self._median: yield self._rightchild # If the function arrives here, the generator will be considered empty # There are no more than two values: the left and the right children Caller: # Create an empty list and a list with the current object reference result, candidates = list(), [self] Loop on candidates (they contain only one element at the beginning) while candidates: # Get the last candidate and remove it from the list node = candidates.pop() # Get the distance between obj and the candidate distance = node._get_dist(obj) # If the distance is ok, then you can fill in the result if distance <= max_dist and distance >= min_dist: result.extend(node._values) # Add the children of the candidate to the candidate's list # so the loop will keep running until it has…", "metadata": {"source": "stackexchange:stackoverflow", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.426, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.426}}
{"format": "qa", "instruction": "How can I rename a local Git branch? How can I rename a local branch which has not yet been pushed to a remote repository? Related: ' operator in C/C++? After reading Hidden Features and Dark Corners of C++/STL on comp.lang.c++.moderated , I was completely surprised that the following snippet compiled and worked in both Visual Studio 2008 and G++ 4.4. I would assume this is also valid C since it works in GCC as well. Here's the code: #include int main() { int x = 10; while (x --> 0) // x goes to 0 { printf(\"%d \", x); } } Output: 9 8 7 6 5 4 3 2 1 0 Where is this defined in the standard, and where has it come from?", "input": "", "output": "--> is not an operator. It is in fact two separate operators, -- and > . The code in the condition decrements x , while returning x 's original (not decremented) value, and then compares the original value with 0 using the > operator. To better understand, the statement could be written as follows: while( (x--) > 0 )", "metadata": {"source": "stackexchange:stackoverflow", "category": "code", "subcategory": "python", "language": "en", "difficulty": "easy", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.35}}
{"format": "qa", "instruction": "What technical details should a programmer of a web application consider before making the site public? What things should a programmer implementing the technical details of a web application consider before making the site public? If [!TIP] > You can also chat with a model directly from the command line, as long as transformers serve is running. > Expand the examples below to see how Pipeline works for different modalities and tasks. Automatic speech recognition Image classification ![\"Hugging](\")
= |PythonMinVersion|) - NumPy (>= |NumPyMinVersion|) - SciPy (>= |SciPyMinVersion|) - Narwhals (>= |NarwhalsMinVersion|) - joblib (>= |JoblibMinVersion|) - threadpoolctl (>= |ThreadpoolctlMinVersion|) ======= Scikit-learn plotting capabilities (i.e., functions start with `plot_ and classes end with Display) require Matplotlib (>= |MatplotlibMinVersion|). For running the examples Matplotlib >= |MatplotlibMinVersion| is required. A few examples require scikit-image >= |Scikit-ImageMinVersion|, a few examples require pandas >= |PandasMinVersion|, some examples require seaborn >= |SeabornMinVersion| and Plotly >= |PlotlyMinVersion|. User installation ~~~~~~~~~~~~~~~~~ If you already have a working installation of NumPy and SciPy, the easiest way to install scikit-learn is using pip:: pip install -U scikit-learn or conda:: conda install -c conda-forge scikit-learn The documentation includes more detailed installation instructions < Changelog See the changelog < for a history of notable changes to scikit-learn. Development We welcome new contributors of all experience levels. The scikit-learn community goals are to be helpful, welcoming, and effective. The Development Guide < has detailed information about contributing code, documentation, tests, and more. We've included some basic information in this README. Important links ~~~~~~~~~~~~~~~ - Official source code repo: - Download releases: - Issue tracker: Source code ~~~~~~~~~~~ You can check the latest sources with the command:: git clone Contributing ~~~~~~~~~~~~ To learn more about making a contribution to scikit-learn, please see our Contributing guide < Testing ~~~~~~~ After installation, you can launch the test suite from outside the source directory (you will need to have pytest >= |PytestMinVersion| installed):: pytest sklearn See the web page for more information. Random number generation can be controlled during testing by setting the SKLEARN_SEED environment variable. See for details. Submitting a Pull Request ~~~~~~~~~~~~~~~~~~~~~~~~~ Before opening a Pull Request, have a look at the full Contributing page to make sure your code complies with our guidelines: Project History The project was started in 2007 by David Cournapeau as a Google Summer of Code project, and since then many volunteers have contributed. See the About us < page for a list of core contributors. Note: scikit-learn was previously referred to as scikits.learn. Help and Support Documentation ~~~~~~~~~~~~~ - HTML documentation (stable release): - HTML documentation (development version): - FAQ: Communication ~~~~~~~~~~~~~ Main Channels ^^^^^^^^^^^^^ - Website: - Blog: - Mailing list: Developer & Support ^^^^^^^^^^^^^^^^^^^^^^ - GitHub Discussions: - Stack Overflow: - Discord: Social Media Platforms ^^^^^^^^^^^^^^^^^^^^^^ - LinkedIn: - YouTube: - Facebook: - Instagram: - TikTok: - Bluesky: - Mastodon: Resources ^^^^^^^^^ - Calendar: - Logos & Branding: Citation ~~~~~~~~ If you use scikit-learn in a scientific publication, we would appreciate citations:", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "keras-team/keras", "text": "Keras 3: Deep Learning for Humans Keras 3 is a multi-backend deep learning framework, with support for JAX, TensorFlow, PyTorch, and OpenVINO (for inference-only). Effortlessly build and train models for computer vision, natural language processing, audio processing, timeseries forecasting, recommender systems, etc. - Accelerated model development: Ship deep learning solutions faster thanks to the high-level UX of Keras and the availability of easy-to-debug runtimes like PyTorch or JAX eager execution. - State-of-the-art performance: By picking the backend that is the fastest for your model architecture (often JAX!), leverage speedups ranging from 20% to 350% compared to other frameworks. Benchmark here. - Datacenter-scale training: Scale confidently from your laptop to large clusters of GPUs or TPUs. Join nearly three million developers, from burgeoning startups to global enterprises, in harnessing the power of Keras 3. Installation Install with pip Keras 3 is available on PyPI as keras. Note that Keras 2 remains available as the tf-keras package. 1. Install keras: 2. Install backend package(s). To use keras, you should also install the backend of choice: tensorflow, jax, or torch. Additionally, The openvino backend is available with support for model inference only. Local installation Minimal installation Keras 3 is compatible with Linux and macOS systems. For Windows users, we recommend using WSL2 to run Keras. To install a local development version: 1. Install dependencies: 2. Run installation command from the root directory. 3. Run API generation script when creating PRs that update keras_export public APIs: Backend Compatibility Table The following table lists the minimum supported versions of each backend for the latest stable release of Keras (v3.x): | Backend | Minimum Supported Version | |------------|---------------------------| | TensorFlow | 2.16.1 | | JAX | 0.4.20 | | PyTorch | 2.1.0 | | OpenVINO | 2026.2.0 | Adding GPU support The requirements.txt file will install a CPU-only version of TensorFlow, JAX, and PyTorch. For GPU support, we also provide a separate requirements-{backend}-cuda.txt for TensorFlow, JAX, and PyTorch. These install all CUDA dependencies via pip and expect a NVIDIA driver to be pre-installed. We recommend a clean Python environment for each backend to avoid CUDA version mismatches. As an example, here is how to create a JAX GPU environment with conda: Configuring your backend You can export the environment variable KERAS_BACKEND or you can edit your local config file at ~/.keras/keras.json to configure your backend. Available backend options are: \"tensorflow\", \"jax\", \"torch\", \"openvino\". Example: In Colab, you can do: Note: The backend must be configured before importing keras, and the backend cannot be changed after the package has been imported. Note: The OpenVINO backend is an inference-only backend, meaning it is designed only for running model predictions using model.predict() method. Backwards compatibility Keras 3 is intended to work as a drop-in replacement for tf.keras (when using the TensorFlow backend). Just take your existing tf.keras code, make sure that your calls to model.save() are using the up-to-date .keras format, and you're done. If your tf.keras model does not include custom components, you can start running it on top of JAX or PyTorch immediately. If it does include custom components (e.g. custom layers or a custom train_step()), it is usually possible to convert it to a backend-agnostic implementation in just a few minutes. In addition, Keras models can consume datasets in any format, regardless of the backend you're using: you can train your models with your existing tf.data.Dataset pipelines or PyTorch DataLoaders. Why use Keras 3? - Run your high-level Keras workflows on top of any framework -- benefiting at will from the advantages of each framework, e.g. the scalability and performance of JAX or the production ecosystem options of TensorFlow. - Write custom components (e.g. layers, models, metrics) that you can use in low-level workflows in any framework. - You can take a Keras model and train it in a training loop written from scratch in native TF, JAX, or PyTorch. - You can take a Keras model and use it as part of a PyTorch-native Module or as part of a JAX-native model function. - Make your ML code future-proof by avoiding framework lock-in. - As a PyTorch user: get access to power and usability of Keras, at last! - As a JAX user: get access to a fully-featured, battle-tested, well-documented modeling and training library. in the Keras 3 release announcement.", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "ultralytics/ultralytics", "text": "中文 | 한국어 | 日本語 | Русский | Deutsch | Français | Español | Português | Türkçe | Tiếng Việt | العربية =3.8 environment with PyTorch>=1.8. For alternative installation methods, including Conda, Docker, and building from source via Git, please consult the Quickstart Guide. Usage CLI You can use Ultralytics YOLO directly from the Command Line Interface (CLI) with the yolo command: The yolo command supports various tasks and modes, accepting additional arguments like imgsz=640. Explore the YOLO CLI Docs for more examples. Python Ultralytics YOLO can also be integrated directly into your Python projects. It accepts the same configuration arguments as the CLI: Discover more examples in the YOLO Python Docs. ✨ Models Ultralytics supports a wide range of YOLO models, from early versions like YOLOv3 to the latest YOLO26. The tables below showcase YOLO26 models pretrained on COCO for Detection, Segmentation, and Pose Estimation. Semantic Segmentation models are pretrained on Cityscapes, Depth Estimation models are pretrained on a broad multi-dataset mix and evaluated on NYU Depth V2, and Classification models are pretrained on ImageNet. Tracking mode is compatible with Detection, Segmentation, Pose, and OBB models. All Models download automatically from the latest Ultralytics release on first use. Detection (COCO) Explore the Detection Docs for usage examples. These models are trained on the COCO dataset, featuring 80 object classes. | Model | size (pixels) | mAP val 50-95 | mAP val 50-95(e2e) | Speed CPU ONNX (ms) | Speed T4 TensorRT10 (ms) | params (M) | FLOPs (B) | | ---------------------------------------------------------------------- | --------------------------- | -------------------------- | ------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | YOLO26n | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.4 | | YOLO26s | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.7 | | YOLO26m | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.2 | | YOLO26l | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.4 | | YOLO26x | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 193.9 | - mAP val values refer to single-model single-scale performance on the COCO val2017 dataset. See YOLO Performance Metrics for details. Reproduce with yolo val detect data=coco.yaml device=0 - Speed metrics are averaged over COCO val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export. Reproduce with yolo val detect data=coco.yaml batch=1 device=0|cpu Segmentation (COCO) Refer to the Segmentation Docs for usage examples. These models are trained on COCO-Seg, including 80 classes. | Model | size (pixels) | mAP box 50-95(e2e) | mAP mask 50-95(e2e) | Speed CPU ONNX (ms) | Speed T4 TensorRT10 (ms) | params (M) | FLOPs (B) | | ------------------------------------------------------------------------------ | --------------------------- | ------------------------------- | -------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | YOLO26n-seg | 640 | 39.6 | 33.9 | 53.3 ± 0.5 | 2.1 ± 0.0 | 2.7 | 9.1 | | YOLO26s-seg | 640 | 47.3 | 40.0 | 118.4 ± 0.9 | 3.3 ± 0.0 | 10.4 | 34.2 | | YOLO26m-seg | 640 | 52.5 | 44.1 | 328.2 ± 2.4 | 6.7 ± 0.1 | 23.6 | 121.5 | | YOLO26l-seg | 640 | 54.4 | 45.5 | 387.0 ± 3.7 | 8.0 ± 0.1 | 28.0 | 139.8 | | YOLO26x-seg | 640 | 56.5 | 47.0 | 787.0 ± 6.8 | 16.4 ± 0.1 | 62.8 | 313.5 | - mAP val values are for single-model single-scale on the COCO val2017 dataset. See YOLO Performance Metrics for details. Reproduce with yolo val segment data=coco.yaml device=0 - Speed metrics are averaged over COCO val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export. Reproduce with yolo val segment data=coco.yaml batch=1 device=0|cpu Semantic Segmentation (Cityscapes) See the Semantic Segmentation Docs for usage examples. These models are trained on Cityscapes, including 19 classes. | Model | size (pixels) | mIoU val | Speed RTX3090 PyTorch (ms) | params (M) | FLOPs (B) | | ------------------------------------------------------------------------------ | --------------------------- | ------------------ | ------------------------------------------- | ------------------------ | ----------------------- | | YOLO26n-sem | 1024 × 2048 | 78.3 | 4.4 ± 0.0 | 1.6 | 22.7 | | YOLO26s-sem | 1024 × 2048 | 80.8 | 8.4 ± 0.0 | 6.5 | 88.8 | | YOLO26m-sem | 1024 × 2048 | 82.0 | 19.9 ± 0.1 | 14.3 | 304.5 | | YOLO26l-sem | 1024 × 2048 | 82.9 | 26.5 ± 0.1 | 17.9 | 384.7 | | YOLO26x-sem | 1024 × 2048 | 83.6 | 48.9 ± 0.2 | 40.2 | 861.7 | - mIoU val values are for single-model single-scale on the Cityscapes validation set. Reproduce with yolo semantic val data=cityscapes.yaml device=0 imgsz=2048 - Speed metrics are averaged over Cityscapes validation images using an RTX3090 instance. Reproduce with yolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048 Depth Estimation (NYU Depth V2) See the Depth Estimation Docs for usage examples. These models are pretrained on a broad multi-dataset mix and evaluated on the NYU Depth V2 Eigen test split, predicting per-pixel depth in meters. | Model | size (pixels) | delta1 NYU | abs_rel NYU | rmse NYU | Speed CPU ONNX (ms) | Speed T4 TensorRT10 (ms) | params (M) | FLOPs (B) | | ---------------------------------------------------------------------------------- | --------------------------- | -------------------- | --------------------- | ------------------ | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | YOLO26n-depth | 768 | 0.882 | 0.109 | 0.414 | 272.0 ± 27.2 | 2.7 ± 0.1 | 6.4 | 46.9 | | YOLO26s-depth | 768 | 0.896 | 0.104 | 0.399 | 393.7 ± 13.1 | 3.8 ± 0.0 | 13.2 | 67.9 | | YOLO26m-depth | 768 | 0.921 | 0.089 | 0.364 | 621.5 ± 49.7 | 6.0 ± 0.1 | 23.3 | 130.7 | | YOLO26l-depth | 768 | 0.930 | 0.083 | 0.351 | 821.9 ± 50.7 | 7.7 ± 0.1 | 27.7 | 157.2 | | YOLO26x-depth | 768 | 0.933 | 0.080 | 0.344 | 1240.9 ± 73.3 | 13.6 ± 0.2 | 57.0 | 302.0 | - delta1 NYU is the percentage of pixels where the predicted depth is within a factor of 1.25 of the ground truth, on the NYU Depth V2 Eigen test split (654 images) with multi-scale + horizontal-flip TTA and log-least-squares alignment. - Single-scale accuracy without TTA is reproducible with yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (substitute model= for each size), which uses median (scale-only) alignment and scores lower: delta1 0.785 (n), 0.786 (s), 0.827 (m), 0.839 (l), 0.843 (x). - abs_rel is the mean absolute relative error between predicted and ground-truth depth values. - rmse is the root mean squared error in meters. - Speed is inference-only latency (pre/post-processing excluded) at imgsz=768, batch=1, reported as mean ± std over timed runs after warmup. CPU ONNX is ONNX Runtime fp32 on a 32-core Intel Xeon (Skylake); T4 TensorRT10 is TensorRT fp16 on a Tesla T4. - params and FLOPs are measured at 768×768, the training resolution of the released weights. Classification (ImageNet) Consult the Classification Docs for usage examples. These models are trained on ImageNet, covering 1000 classes. | Model | size (pixels) | acc top1 | acc top5 | Speed CPU ONNX (ms) | Speed T4 TensorRT10 (ms) | params (M) | FLOPs (B) at 224 | | ------------------------------------------------------------------------------ | --------------------------- | ---------------------- | ---------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ------------------------------ | | YOLO26n-cls | 224 | 71.4 | 90.1 | 5.0 ± 0.3 | 1.1 ± 0.0 | 2.8 | 0.5 | | YOLO26s-cls | 224 | 76.0 | 92.9 | 7.9 ± 0.2 | 1.3 ± 0.0 | 6.7 | 1.6 | | YOLO26m-cls | 224 | 78.1 | 94.2 | 17.2 ± 0.4 | 2.0 ± 0.0 | 11.6 | 4.9 | | YOLO26l-cls | 224 | 79.0 | 94.6 | 23.2 ± 0.3 | 2.8 ± 0.0 | 14.1 | 6.2 | | YOLO26x-cls | 224 | 79.9 | 95.0 | 41.4 ± 0.9 | 3.8 ± 0.0 | 29.6 | 13.6 | - acc values represent model accuracy on the ImageNet dataset validation set. Reproduce with yolo val classify data=path/to/ImageNet device=0 - Speed metrics are averaged over ImageNet val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export. Reproduce with yolo val classify data=path/to/ImageNet batch=1 device=0|cpu Pose (COCO) See the Pose Estimation Docs for usage examples. These models are trained on COCO-Pose, focusing on the 'person' class. | Model | size (pixels) | mAP pose 50-95(e2e) | mAP pose 50(e2e) | Speed CPU ONNX (ms) | Speed T4 TensorRT10 (ms) | params (M) | FLOPs (B) | | -------------------------------------------------------------------------------- | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | YOLO26n-pose | 640 | 57.2 | 83.3 | 40.3 ± 0.5 | 1.8 ± 0.0 | 2.9 | 7.5 | | YOLO26s-pose | 640 | 63.0 | 86.6 | 85.3 ± 0.9 | 2.7 ± 0.0 | 10.4 | 23.9 | | YOLO26m-pose | 640 | 68.8 | 89.6 | 218.0 ± 1.5 | 5.0 ± 0.1 | 21.5 | 73.1 | | YOLO26l-pose | 640 | 70.4 | 90.5 | 275.4 ± 2.4 | 6.5 ± 0.1 | 25.9 | 91.3 | | YOLO26x-pose | 640 | 71.6 | 91.6 | 565.4 ± 3.0 | 12.2 ± 0.2 | 57.6 | 201.7 | - mAP val values are for single-model single-scale on the COCO Keypoints val2017 dataset. See YOLO Performance Metrics for details. Reproduce with yolo val pose data=coco-pose.yaml device=0 - Speed metrics are averaged over COCO val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export. Reproduce with yolo val pose data=coco-pose.yaml batch=1 device=0|cpu Oriented Bounding Boxes (DOTAv1) Check the OBB Docs for usage examples. These models are trained on DOTAv1, including 15 classes. | Model | size (pixels) | mAP test 50-95(e2e) | mAP test 50(e2e) | Speed CPU ONNX (ms) | Speed T4 TensorRT10 (ms) | params (M) | FLOPs (B) | | ------------------------------------------------------------------------------ | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | YOLO26n-obb | 1024 | 52.4 | 78.9 | 97.7 ± 0.9 | 2.8 ± 0.0 | 2.5 | 14.0 | | YOLO26s-obb | 1024 | 54.8 | 80.9 | 218.0 ± 1.4 | 4.9 ± 0.1 | 9.8 | 55.1 | | YOLO26m-obb | 1024 | 55.3 | 81.0 | 579.2 ± 3.8 | 10.2 ± 0.3 | 21.2 | 183.3 | | YOLO26l-obb | 1024 | 56.2 | 81.6 | 735.6 ± 3.1 | 13.0 ± 0.2 | 25.6 | 230.0 | |…", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "deepfakes/faceswap", "text": "deepfakes_faceswap Important information for Patreon and PayPal supporters. Please see this forum post: = 384.81) and Nvidia-Docker installed can run the example on the GPU: Open the docker-compose.yml file and uncomment the dockerfile: Dockerfile.gpu and runtime: nvidia lines. Having problems? If you run into problems, please read the Common Errors section of the wiki before filing a github issue. Thanks Many, many thanks to Davis King (@nulhom) for creating dlib and for providing the trained facial feature detection and face encoding models used in this library. For more information on the ResNet that powers the face encodings, check out his blog post. Thanks to everyone who works on all the awesome Python data science libraries like numpy, scipy, scikit-image, pillow, etc, etc that makes this kind of stuff so easy and fun in Python. * Thanks to Cookiecutter and the audreyr/cookiecutter-pypackage project template for making Python project packaging way more tolerable.", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.363, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": true, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.0}}
{"format": "sequential_text", "title": "Front End Interview Handbook for domain expertise and practice", "text": "Front End Interview Handbook By whs is currently at v2 major version. We had plans for v3 yet but development isn't active. So v2 will probably remain the main stable version until further notice. > We try to publish minor update releases for bug fixes, we will review PRs. NPM > For whs@2.2.x (Three.js r92) use @beta tag [![NPM Version][npm]][npm-url] Basic setup Download the minified library or link the one from CDN The code below makes a WHS.App instance which handles all your modules and components for better work with WebGL. This one creates a _scene_, _camera_ and _renderer_ - we add the following modules to the App. Featured projects Useful resources for creating Progressive Web Apps What is a Progressive Web App > A Progressive Web App uses modern web capabilities to deliver an app-like user experience. They evolve from pages in browser tabs to immersive, top-level apps, leveraging the web's low friction. _Source:_ Google Developers - Progressive Web Apps PWA Checklist HTTPS Service Worker Web App Manifest Responsive Design Offline Support Table of contents App Directories Apps Audio and Video Business and Finance Communication and Social Development and Design Education and Reading Games and Entertainment Health and Lifestyle News and Information Shopping and Travel Tools and Utilities Miscellaneous Tutorials Articles Getting Started and Introductions Case Studies and Real-World Apps Performance and Optimization Technical Guides and Deep Dives Videos Google I/O Progressive Web App Summit 2016 Chrome Dev Summit Other Talks and General Concepts Tools Generators and CLIs Service Worker Libraries Webpack and Framework Plugins Testing and Auditing Miscellaneous Utilities Kits Courses Conferences App Directories 0data.app store.app webappfinder.app Apps - Gyeonggi Currency Map - Interactive PWA mapping municipal local-currency merchant locations across 31 cities of Gyeonggi Province, South Korea. Real-time \"open now\" filter, KakaoTalk share, public open data. React + Vite + Leaflet on Firebase Hosting. Audio and Video BitMidi: Listen to your favorite MIDI files. Foldergram: Local-only photo and video gallery for folders, with an Instagram-inspired browsing pattern. guitar-tuner: Aerotwist Guitar Tuner Joybox: A pinboard for audiovisual media. Lofimusic.app: Online radio Radio Music Player PWA: Music Player. OmniCam: Live streaming webcams around the world. Remove Audio: Browser-based tool to strip the soundtrack from any video locally with WebAssembly and FFmpeg.wasm. No uploads, no sign-up, batch up to 20 clips. SoundCloud: Stream and listen to music. Soundslice: Create living sheet music. Spotify: Music streaming. SvenPanel: The Shrine - The Message Is Feierei Alda. VideoTrim.app: Video trimmer app in the browser. Wave-PD1: Synth toy. X Sound: Online keyboard synth. Youtube Music: Music streaming via YouTube. Business and Finance FarmOS: Farm record keeping Freelancer: Hire the best freelancers for any job, online. Invoice Otter: Send estimates and invoices with AI, get paid instantly, track expenses. JustInvoice: An intuitive invoice manager that works completely in the browser and offline. MoneyTracker: Personal finances tracking web app. MTGStocks: Magic the Gathering price tracker. pix2qr: Generate, read, and re-render Brazilian PIX payment codes locally in the browser; installable and works offline. Rydeen: Task management app for individuals. Simple Currency Converter: Currency Converter Skcript: Ruby on Rails Consulting. SplittyPie: Easy expense splitting. Taskade: Remote Team Workspace. Tender: Personal finance app. TuxBank: Budget calendar, local first, optional e2ee sync. Vaulted: Local-first net worth tracker PWA with no account, no bank sync, and no server. WalletLens — Net worth tracker PWA — crypto, stocks, gold, fiat, cash. Installable, works offline, no account required. Communication and Social Bloom Pro: Bloom Pro – Your Grow Journal - Keep track of your grows Chitchatter: Secure peer-to-peer chat that is serverless, decentralized, and ephemeral Datememe: Online dating. emberclear: Encrypted Chat. No History. No Logs. ghChat: Chat application for GitHub. Google Duo: Video Calling. Medium: Writing space. Messages for web (by google): 400 Similar Worlds: Experience Project Alternative. Find people with similar interests. Telegram: Telegram Web App. Threema Web: The messenger that puts security and privacy first. Tinder: Dating app. Twitter: Microblogging app. Development and Design 3D House Editor: Free 3D floor planner ampproject: Web component framework. Bento-starter: Open-Source Full-Stack solution for fast PWA development bundle: A quick and easy way to bundle, minify, and compress (gzip and brotli) your ts, js, jsx and npm projects all online, with the resulting file size. ColorBeta: Advanced CSS Gradient Generator Demo PWA: Demonstrating offline, push notifications, background sync etc. DevDocs: API Documentation Browser Hyperdraft: Turn your text notes into a website. JSON Formatter: Minimalist JSON formatter. Launchlet: Customize any website with JavaScript or CSS. Make Better Software: Raise software standards. MYHELLOIOT: MQTT client application. Photopea: Online Photo Editor. PixelCraft: Pixel Art Editor Regex101: Build, test and debug regex. Shademix: Free colour toolkit — eyedropper, 10 paint-system matcher (RAL, NCS, Pantone-equivalent), OKLCH harmonies, WCAG contrast, CMYK warnings, 11 export formats. Runs entirely client-side, no signup. SVGOMG: SVGO's Missing GUI Termdeck: Browser control plane for the Claude Code, Codex and Grok coding-agent CLIs running on your own machines. Installable, with Web Push notifications when an agent needs a tool approved. Themer: Theme generator for editors, terminals, wallpapers, and more. TurboPixel: PixelArt Camera PWA webpushtest: Web Push Notifications Demo Online Notepad With Share: Online Notepad – Free Online Text Editor & Notes Sharing Share Text Online Live: Share Text Online Live——Create, edit, and share text online with secure links and QR codes – No Login and registration required Education and Reading Booksie: An open catalog of free picture storybooks for children instantly available for reading. EPUB Player: A fully-featured audiobook player with Audible/Spotify-like UX, powered by local TTS models. Turn your EPUBs into audiobooks entirely in-browser. Shiori: Open-source AI study companion — SRS flashcards, GPA predictor, Gemini AI study plans, AI quiz generator, habit tracker. Installable PWA, works offline. Google Classroom sync. GitHub Kommit: Create flashcards and learn them with spaced-repetition. PracticeLoop: Slow down & loop YouTube videos for music practice with progressive speed training. Room TBA: Offline-capable campus map PWA for finding rooms, class schedules, and transit routes on OpenStreetMap data. Swahili Dictionary: Offline Swahili-English-Swahili dictionary Timetable: Interactive editable timetable. Tutor Portfolio PWA: ??? Unalengua IPA Translator: Translate to IPA. WordDB: Word finder, thesaurus, dictionary, crossword solver, rhyme finder and more. Room TBA: UPLB campus room finder with offline PGlite cache and installable PWA. Games and Entertainment 2048 Game 2048 Game Air Horner: Air horn sound. Backgammon: Backgammon game with local multiplayer (no single player). Colosseum: Displays Pokemons in a beautiful way Crazy Dice: Simple Dice App. Cybercar: Free neon arcade survival game with power-ups, unlockable themes, boss battles, and global leaderboard. Falling Nikochan: Simple and cute rhythm game, where anyone can create and share charts. Farmhand: A resource management game that puts a farm in your hand Friends-Hunt: Real-world geo-game in the style of popular YouTube formats. Life counter: Life counter app for 2 players. Supports game profiles, cout up/down. Math Riddles: Interesting Math Riddles. Memory Game PWA: Strengthen your memory. MoodMovie: Mood-based movie & TV show finder — pick how you feel and get personalized picks with legal streaming links. Murlok.io: World of Warcraft Shadowlands. Othello: Play Othello against the computer. Play Park: Free family games — trivia, word puzzles, memory match, and more. No account, no ads. Player order selector: Random player order selector. Pokedex: Indexing Pokémon PokeQuest Wiki: Search for Pokémon PWA-NES: 8-bit NES emulator Slitherlinks: Free online Slitherlink puzzle platform with 1900+ puzzles, daily challenges, and global leaderboards. Solitaire: Play solitaire games in this lightweight PWA. Online or Offline. Soodoku: Advanced sudoku game, works online & offline, without ads and distractions. Stillgrid: Sudoku with variants (X, jigsaw, killer) at 6×6–16×16, technique-graded difficulty, works offline. Virus Wars: Virus Wars game with local multiplayer (no single player). Yahtzee: Dice generator. Health and Lifestyle Aerko_: Offline-first, brutalist fitness & nutrition PWA with local AI biomechanics (MediaPipe) and AES-256 encryption. Archery Note: Privacy-first archery practice notebook PWA — scoring, sight marks, equipment, and on-device AI form tracking. No account, no ads, works offline. Calorie Tracker: Free, private calorie & macro tracker. No account, offline-capable, with barcode scanning; all data stays on your device. Care Cards: Care Cards Cat Safe Foods: Sharing food with your cat? Make sure it's safe first Chompass: Ad-free calorie and food diary PWA. local-first diary and body metrics, optional BYOK AI, open JSON export. No account required. ClearLungs: Free private streak tracker for quitting smoking. Track recovery phases, milestones, and share progress. CuidaLocal: Local-first, offline caregiver organizer in English with accessible simple and full modes, calendar export, and local reminders. Dog Safe Foods: Sharing food with your dog? Make sure it's safe first DoHabit: Minimalist account-free habit tracker with a native mobile feel. FastTrack: Free intermittent fasting streak tracker with metabolic phases and milestone celebrations. Forge - A lightweight PWA for logging workouts with offline-first architecture and cross-device sync. Longevity World Cup: Open-source longevity sport platform with biological-age calculators, athlete profiles, and public leaderboards. OpenHabitTracker: Take notes, plan tasks, track habits. Free, open source, works offline, no account, all data stays on your device. Progressive: Local-first hypertrophy training tracker, fully offline and event-sourced. Progressive Beer: Progressive Beer Push or Pay: Free couples streak-tracking PWA. Protect your daily push-up streak or your partner collects a playful \"Lazy Tax.\" No account beyond an invite link, works offline. Recipe Jar: Local-first recipe keeper. Paste a link, get a clean ad-free card, save unlimited recipes offline. No account, open source. Rewire: Free private streak tracker for building better habits. Track recovery phases, earn milestones, and share progress cards. VapeFree: Free private streak tracker for quitting vaping. Track lung recovery phases, milestones, and share progress. Veganify: Check if a product is vegan or not. Luna Tarot: Free multilingual tarot reading PWA with 8-language support, daily readings, meditation music, and moon calendar. Works offline, no signup required. News and Information Brutalist Hacker News: A Hacker News reader inspired by Brutalist Web design, Cyberpunk, retro computing, Y2K Aesthetics ComputerBase: German IT news site. Qi Reader: A modern web RSS reader. Shopping and Travel Digikala: Digikala Web App Google Maps: Online maps. Housing Go: Real estate in India. StoryRoute: AI-powered GPS audio tour guide that generates real-time spoken narratives about places around you. trivago: Hotel prices. Uber Web: Ridesharing app. Versus: Consumer electronics shopping. Zirvə: Free GPS altitude finder — know your exact elevation above sea level instantly. No app, no sign-up. Tools and Utilities 2brew: PWA timer for coffee brewing AlarmDJ: Online alarm clock that plays MP3 files or YouTube videos. Anonynote: Note-taking app. Bangle.io: Local-first Markdown note-taking PWA with WYSIWYG editing and no account required. BulkPicTools: Privacy-first, browser-side bulk image optimizer and editor. Calculator: A calculator app with theme switcher ChipBreaker: Offline speeds & feeds and tap drill calculator for machinists — eight shop tools, zero internet. No account, no subscription. Emoji Log: Personal tracker Google Drive: File storage. Google Photos: Photo management. GPA Calculator: Generate animated artwork from your unique GPA inputs. GPA Calculator: Calculate your college GPA. gottrix: Free…", "metadata": {"source": "github_readme", "category": "code", "subcategory": "javascript", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "redom/redom", "text": "Develop web applications with 100% JavaScript and web standards. 🚀 RE:DOM is a tiny (2 KB) UI library by Juha Lindstedt and contributors, which adds some useful helpers to create DOM elements and keeping them in sync with the data. Because RE:DOM is so close to the metal and doesn't use virtual dom, it's actually faster and uses less memory than almost all virtual dom based libraries, including React (benchmark). It's also easy to create reusable components with RE:DOM. Another great benefit is, that you can use just pure JavaScript, so no complicated templating languages to learn and hassle with. Supporting RE:DOM RE:DOM is an MIT-licensed open source project with its ongoing development made possible entirely by the support of these awesome backers. If you'd like to join them, please consider: - Become a backer or sponsor on Open Collective. Installation Documentation To check out live examples and docs, visit RE:DOM. Questions For questions and support please use community chat. Tools - NO:DOM (server-side rendering) - Project generator - Dev tools for Chrome - Babel RE:DOM JSX transform Performance - RE:DOM is one of the fastest UI libraries out there. Issues Please make sure to read the Issue Reporting Checklist before opening an issue. Issues not conforming to the guidelines may be closed immediately. Changelog Detailed changes for each release are documented in the release notes. Contribution Please make sure to read the Contributing Guide before making a pull request.\\ Thank you to all the people who already contributed to RE:DOM! This project is maintained with :heart: by folks on multiple teams at Esri, but we provide no guarantee of individual features, nor a traditional product lifecycle to support planning. The goal of this project is not to replace the ArcGIS Maps SDK for JavaScript but rather to provide small components for _only some_ aspects of the ArcGIS platform for developers who prefer to build mapping applications with Leaflet. We are proud to facilitate a project which requires participation from our diverse user community in order to thrive and we welcome contributions from those just getting their feet wet in open-source. Support for Geocoding services and Geoprocessing services, as well as service defined rendering are available as well (via additional plugins). > If you'd like to display Esri services in _any_ Leaflet application, we ask that you adhere to our Terms of Use and attribution requirements. Table of Contents - Getting Started - Quick Start - Samples, Tutorials, and API Reference - Additional Plugins - Frequently Asked Questions - Issues - Dependencies - Going Deeper - Development Instructions - Versioning - Contributing - Terms - Credit - License Quick Start The easiest way to get started is to load Esri Leaflet via CDN. Here is an example you can copy/paste into your own .html file: Esri Leaflet Quick Start Samples, Tutorials, and API Reference Samples, tutorials, and the API reference can be found at developers.arcgis.com/esri-leaflet. If you notice any issues or would like to propose a change to the documentation, _please_ let us know by creating an issue in this repository. Additional Plugins Many folks have written plugins to customize and extend Leaflet. You can also pick and choose additional Esri Leaflet plugins. Frequently Asked Questions - What are the terms of use for ArcGIS Online services? - What exactly is Esri Leaflet? Is it a replacement for Leaflet? - Will Esri Leaflet replace the ArcGIS Maps SDK for JavaScript? - What is the benefit of using Esri Leaflet over using Leaflet all by itself? - What are the goals of Esri Leaflet? - Can I use Esri Leaflet with Leaflet Version 1.0.x? - How do you decide what features get included in Esri Leaflet? - I have an idea! What should I do? - When will you support \"x\"? - Can you implement feature \"x\"? - I want to contribute. How can I help? - I built something with Esri Leaflet can I show you? - I built a reusable component (layer type, api wrapper, ui control etc...) can I contribute it to Esri Leaflet? - Which services require authentication? - What are some good Leaflet Plugins? - What browsers does Esri Leaflet support? - What versions of ArcGIS Server does Esri Leaflet support? - Upgrading the version of Esri Leaflet used in my app broke everything! - Does Esri Leaflet support IE 'compatibility mode'? - I'm into TypeScript, but Esri Leaflet seems to be a vanilla JS thing. Can I find typings somewhere? - When _exactly_ do I need to use a paid Esri developer account to deploy to production? Issues If something isn't working the way you expected, please take a look at previously logged issues that resolve common problems first. Have you found a new bug? Want to request a new feature? We'd love to hear from you. Please let us know by submitting an issue. If you're looking for help you can also find answers on Stack Overflow and GeoNet. Going Deeper Development Instructions If you'd like to inspect and modify the source of Esri Leaflet, follow the instructions below to set up a local development environment. 1. Fork and clone Esri Leaflet 2. cd into the esri-leaflet folder 3. Install the package.json dependencies by running npm install 4. Run npm start from the command line. This will compile minified source in a brand new dist directory, launch a tiny webserver and begin watching the raw source for changes. 5. Run npm test to make sure you haven't introduced a new 'feature' accidentally. 6. Make your changes and create a pull request Dependencies - Esri Leaflet 1.x (available on CDN) can be used in apps alongside: - Leaflet version 0.7.x. - Esri Leaflet 2.x (available on CDN) can be used in apps alongside: - Leaflet version 1.x. The master branch of this repository is _only_ compatible with Leaflet 1.x. Versioning For transparency into the release cycle and in striving to maintain backward compatibility, Esri Leaflet is maintained under Semantic Versioning guidelines and will adhere to these rules whenever possible. For more information on SemVer, please visit < Contributing Esri welcomes contributions from anyone and everyone. Please see our guidelines for contributing. Terms If you're using Esri content and services, you'll need to license your usage with an API key or an ArcGIS identity. Full details can be found here: Deployment guidelines. If you display an ArcGIS Online service in any Leaflet application, we require that you include Esri attribution and recognize data providers. Using this plugin, it couldn't be easier to follow the terms. Just select your basemap and the appropriate credits will be displayed dynamically in Leaflet's own Attribution control as users pan/zoom. - Esri Attribution Requirements - Licensing & Attribution Credit - L.esri.DynamicMapLayer originally used code from AGS.Layer.Dynamic.js - L.esri.TiledMapLayer adapts some code from arcgis-level-fixer License Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at > Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. A copy of the license is available in the repository's LICENSE file.", "metadata": {"source": "github_readme", "category": "code", "subcategory": "javascript", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": true, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.0}}
{"format": "sequential_text", "title": "jstrieb/urlpages", "text": "URL Pages jstrieb.github.io/urlpages About - Create web pages in the simple, fast editor - Share code that others can edit and modify - Clone web pages with the bookmarklet (under active development) - \"Publish\" web pages instantaneously - Published links never stop working and ~cannot be taken down~ function as long as this site is trusted and extant - No dependencies - No signups - No tracking - No hosting - No cost - No commitment - A few hundred total lines of clear, well-documented HTML, CSS, and JavaScript Read the Hacker News Discussion here Encrypt It is now possible to encrypt URL Pages using Link Lock. This static, distributed web application uses AES in the browser to encrypt the URL without transmitting any data. The encrypted link is then stored in a Link Lock URL, which, when visited, can only be unlocked with a password. How it works As hinted by its name, URL Pages works by storing the entire contents of a web page in the URL. Thus, as long as the URL exists, so does the page it points to. The rest of the URL Pages program is responsible for translating between web page code (HTML/CSS/JavaScript) and an \"encoded\" URL. - The main page takes encoded data from the URL, decodes it into regular web page format, and displays it to the user - The editor encodes user-created web page data as a link that can be shared - The bookmarklet takes a page that already exists and encodes it as a link that can be shared When the main page is visited, the data is encoded in the URL using base 64 encoding via JavaScript's atob and btoa functions in conjunction with its encodeURIComponent and decodeURIComponent functions. The encoded data is stored in the hash portion of the URL. In the editor, data is similarly encoded, except that the HTML, CSS, and JavaScript portions are stored separately in one object that is converted to a JSON string before being base 64 encoded. The obvious downside of URL Pages is that the links get very long very quickly. Luckily, some URL shorteners are able to accommodate fairly long URLs (shoutout to TinyUrl). In a strange way, this effectively means the link shortener is acting as the web host since it is responsible for storing the record of the web page's data. For simple web pages (and even simple page hierarchies), URL Pages have proven reasonably easy and effective to use, however it quickly becomes infeasible to use for large sites or large embedded images. Disclaimer This just becomes a toy if I am the only one hosting a running version of this repository. If you believe it has real potential, clone it or fork your own version that addresses any non-fundamental problems you have with it, and host your own. The only way this actually becomes robust is if there is no single point of failure (i.e. my GitHub Pages) Web pages in URLs are definitely not how things on the web were meant to be done, so don't be surprised if trying to use URL Pages causes unexpected issues. For example, sharing these links may cause chat programs, email clients, and unsuspecting individuals to get confused, raise exceptions, or complain. Likewise, copy-pasting these links may take a long time, if it works at all. I've also noticed my browser running a little hotter while I've got 5MB links in the URL bar. Furthermore, URL Pages is very much a proof of concept, and should not be relied upon for anything consequential. Read the code and understand it before using so that you understand any associated risks. The codebase was written with readers in-mind. Since the codebase is intentionally short, it can be read and digested fairly quickly if you have prior experience with client-side web applications. I originally conceived this as a simple, static CodePen clone, but I felt the \"publishing\" of pages as URLs was an interesting idea. So I decided to present that aspect of it front and center, even though it wasn't really the point of the project at the beginning. About a year ago, I had a proof of concept version that I ended up using fairly frequently for sharing quick HTML/CSS/JavaScript experiments (never as a means of seriously publishing and sharing censorship-proof content). I found that if its use is limited to that case, it is actually very handy and robust! Examples The following examples were made and \"published\" using the provided code editor. - My personal website - Code in the code editor here - \"Published\" version here - Bookmarklet setup page - Code in the code editor here - \"Published\" version here - A page with embedded images (no external image host) - Code in the code editor here - \"Published\" page here The following examples were cloned from existing pages using the bookmarklet. - My dad's food blog here - The entire editor encoded in the URL here - This GitHub project page here - A cloned New York Times Article here Bookmarklet Currently, the bookmarklet is very much in-development (read: mostly doesn't work). Feel free to try it anyway by visiting the link below and following the instructions. - Bookmarklet instruction page Code for the bookmarklet can be found in bookmarklet.js. The bookmarklet enables some of the most interesting and promising opportunities for URL Pages. Namely: cloning pages for archival purposes, sharing restricted information to bypass censorship, bypassing paywalls, storing entire pages in bookmarks, etc. Related Projects Since its original creation, it has been forked many times. Please open an issue if you would like me to link back to a fork or mirror. - One particularly improved version is JSPen - JSPen - Post about the creation of JSPen Similar in some ways (though unrelated) to the following projects - itty.bitty.site - TinyEditor Project Status This project is actively maintained. If there are no recent commits, it means that everything has been running smoothly! URL Pages is designed to be 100% backwards-compatible, so your links will never break. Even if something were to happen to me, and I could not continue to work on the project, URL Pages will continue to work as long as my GitHub account is open and the jstrieb.github.io domain is online. To-do - Improve the bookmarklet -- it's mostly unusable as of right now - Fix relative vs absolute linking - Maybe try embedding images - Import all srced scripts directly - Improve UI in general and editors beyond simple textarea (perhaps integrate Ace or CodeMirror) - Make the buttons better/more efficient (don't update href on every key press) - Figure out and publish max URL sizes for various URL shorteners - Implement URL compression using Brotli for shorter URLs - Add option to \"publish\" pages using base65536 as suggested here - Upload examples of multi-page sites (tree hierarchy)", "metadata": {"source": "github_readme", "category": "code", "subcategory": "javascript", "language": "en", "difficulty": "medium", "clarity_score": 0.387, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.387}}
{"format": "sequential_text", "title": "jwasham/coding-interview-university", "text": "Coding Interview University > I originally created this as a short to-do list of study topics for becoming a software engineer, > but it grew to the large list you see today. After going through this study plan, I got hired > as a Software Development Engineer at Amazon! > You probably won't have to study as much as I did. Anyway, everything you need is here. > > I studied about 8-12 hours a day, for several months. This is my story: Why I studied full-time for 8 months for a Google interview > > Please Note: You won't need to study as much as I did. I wasted a lot of time on things I didn't need to know. More info about that is below. I'll help you get there without wasting your precious time. > > The items listed here will prepare you well for a technical interview at just about any software company, > including the giants: Amazon, Facebook, Google, and Microsoft. > > Best of luck to you! Translations: - Bahasa Indonesia - Bulgarian - Español - German - Japanese (日本語) - Marathi - Polish - Português Brasileiro - Russian - Tiếng Việt - Vietnamese - Urdu - اردو - Uzbek - বাংলা - Bangla - ខ្មែរ - Khmer - 简体中文 - 繁體中文 Translations in progress: - Afrikaans - Arabic - French - Greek - Italian - Korean(한국어) - Malayalam - Persian - Farsi - Telugu - Thai - Turkish - Українська - עברית - हिन्दी What is it? This is my multi-month study plan for becoming a software engineer for a large company. Required: A little experience with coding (variables, loops, methods/functions, etc) Patience Time Note this is a study plan for software engineering, not frontend engineering or full-stack development. There are really super roadmaps and coursework for those career paths elsewhere (see for more info). There is a lot to learn in a university Computer Science program, but only knowing about 75% is good enough for an interview, so that's what I cover here. For a complete CS self-taught program, the resources for my study plan have been included in Kamran Ahmed's Computer Science Roadmap: Table of Contents The Study Plan - What is it? - Why use it? - How to use it - Don't feel you aren't smart enough - A Note About Video Resources - Choose a Programming Language - Books for Data Structures and Algorithms - Interview Prep Books - Don't Make My Mistakes - What you Won't See Covered - The Daily Plan - Coding Question Practice - Coding Problems Topics of Study - Algorithmic complexity / Big-O / Asymptotic analysis - Data Structures - Arrays - Linked Lists - Stack - Queue - Hash table - More Knowledge - Binary search - Bitwise operations - Trees - Trees - Intro - Binary search trees: BSTs - Heap / Priority Queue / Binary Heap - balanced search trees (general concept, not details) - traversals: preorder, inorder, postorder, BFS, DFS - Sorting - selection - insertion - heapsort - quicksort - mergesort - Graphs - directed - undirected - adjacency matrix - adjacency list - traversals: BFS, DFS - Even More Knowledge - Recursion - Dynamic Programming - Design Patterns - Combinatorics (n choose k) & Probability - NP, NP-Complete and Approximation Algorithms - How computers process a program - Caches - Processes and Threads - Testing - String searching & manipulations - Tries - Floating Point Numbers - Unicode - Endianness - Networking - Final Review Getting the Job - Update Your Resume - Find a Job - Interview Process & General Interview Prep - Be thinking of for when the interview comes - Have questions for the interviewer - Once You've Got The Job ---------------- Everything below this point is optional ---------------- Optional Extra Topics & Resources - Additional Books - System Design, Scalability, Data Handling (if you have 4+ years experience) - Additional Learning - Compilers - Emacs and vi(m) - Unix command line tools - Information theory - Parity & Hamming Code - Entropy - Cryptography - Compression - Computer Security - Garbage collection - Parallel Programming - Messaging, Serialization, and Queueing Systems - A - Fast Fourier Transform - Bloom Filter - HyperLogLog - Locality-Sensitive Hashing - van Emde Boas Trees - Augmented Data Structures - Balanced search trees - AVL trees - Splay trees - Red/black trees - 2-3 search trees - 2-3-4 Trees (aka 2-4 trees) - N-ary (K-ary, M-ary) trees - B-Trees - k-D Trees - Skip lists - Network Flows - Disjoint Sets & Union Find - Math for Fast Processing - Treap - Linear Programming - Geometry, Convex hull - Discrete math - Additional Detail on Some Subjects - Video Series - Computer Science Courses - Papers Why use it? If you want to work as a software engineer for a large company, these are the things you have to know. If you missed out on getting a degree in computer science, like I did, this will catch you up and save four years of your life. When I started this project, I didn't know a stack from a heap, didn't know Big-O anything, or anything about trees, or how to traverse a graph. If I had to code a sorting algorithm, I can tell ya it would have been terrible. Every data structure I had ever used was built into the language, and I didn't know how they worked under the hood at all. I never had to manage memory unless a process I was running would give an \"out of memory\" error, and then I'd have to find a workaround. I used a few multidimensional arrays in my life and thousands of associative arrays, but I never created data structures from scratch. It's a long plan. It may take you months. If you are familiar with a lot of this already it will take you a lot less time. ⬆ back to top How to use it Everything below is an outline, and you should tackle the items in order from top to bottom. I'm using GitHub's special markdown flavor, including tasks lists to track progress. - More about GitHub-flavored markdown If you don't want to use git On this page, click the Code button near the top, then click \"Download ZIP\". Unzip the file and you can work with the text files. If you're open in a code editor that understands markdown, you'll see everything formatted nicely. If you're comfortable with git Create a new branch so you can check items like this, just put an x in the brackets: [x] 1. Fork the GitHub repo: ` by clicking on the Fork button. 1. Clone to your local repo: 1. Mark all boxes with X after you completed your changes: ⬆ back to top Don't feel you aren't smart enough - Successful software engineers are smart, but many have an insecurity that they aren't smart enough. - The following videos may help you overcome this insecurity: - The myth of the Genius Programmer - It's Dangerous to Go Alone: Battling the Invisible Monsters in Tech ⬆ back to top A Note About Video Resources Some videos are available only by enrolling in a Coursera or EdX class. These are called MOOCs. Sometimes the classes are not in session so you have to wait a couple of months, so you have no access. It would be great to replace the online course resources with free and always-available public sources, such as YouTube videos (preferably university lectures), so that you people can study these anytime, not just when a specific online course is in session. ⬆ back to top Choose a Programming Language You'll need to choose a programming language for the coding interviews you do, but you'll also need to find a language that you can use to study computer science concepts. Preferably the language would be the same, so that you only need to be proficient in one. For this Study Plan When I did the study plan, I used 2 languages for most of it: C and Python C: Very low level. Allows you to deal with pointers and memory allocation/deallocation, so you feel the data structures and algorithms in your bones. In higher-level languages like Python or Java, these are hidden from you. In day-to-day work, that's terrific, but when you're learning how these low-level data structures are built, it's great to feel close to the metal. - C is everywhere. You'll see examples in books, lectures, videos, everywhere while you're studying. - The C Programming Language, 2nd Edition - This is a short book, but it will give you a great handle on the C language and if you practice it a little you'll quickly get proficient. Understanding C helps you understand how programs and memory work. - You don't need to go super deep in the book (or even finish it). Just get to where you're comfortable reading and writing in C. Python: Modern and very expressive, I learned it because it's just super useful and also allows me to write less code in an interview. This is my preference. You do what you like, of course. You may not need it, but here are some sites for learning a new language: - Exercism - Codewars - HackerEarth - Scaler Topics (Java, C++) - Programiz PRO Community Challenges) For your Coding Interview You can use a language you are comfortable in to do the coding part of the interview, but for large companies, these are solid choices: - C++ - Java - Python You could also use these, but read around first. There may be caveats: - JavaScript - Ruby Here is an article I wrote about choosing a language for the interview: Pick One Language for the Coding Interview. This is the original article my post was based on: Choosing a Programming Language for Interviews You need to be very comfortable in the language and be knowledgeable. about choices: - Choose the Right Language for Your Coding Interview See language-specific resources here ⬆ back to top Books for Data Structures and Algorithms This book will form your foundation for computer science. Just choose one, in a language that you will be comfortable with. You'll be doing a lot of reading and coding. Python - Coding Interview Patterns: Nail Your Next Coding Interview (Main Recommendation) - An insider’s perspective on what interviewers are truly looking for and why. - 101 real coding interview problems with detailed solutions. - Intuitive explanations that guide you through each problem as if you were solving it in a live interview. - 1000+ diagrams to illustrate key concepts and patterns. C - Algorithms in C, Parts 1-5 (Bundle), 3rd Edition - Fundamentals, Data Structures, Sorting, Searching, and Graph Algorithms Java Your choice: - Goodrich, Tamassia, Goldwasser - Data Structures and Algorithms in Java - Sedgewick and Wayne: - Algorithms - Free Coursera course that covers the book (taught by the authors!): - Algorithms I - Algorithms II C++ Your choice: - Goodrich, Tamassia, and Mount - Data Structures and Algorithms in C++, 2nd Edition - Sedgewick and Wayne - Algorithms in C++, Parts 1-4: Fundamentals, Data Structure, Sorting, Searching - Algorithms in C++ Part 5: Graph Algorithms ⬆ back to top Interview Prep Books Here are some recommended books to supplement your learning. - Coding Interview Patterns: Nail Your Next Coding Interview - Programming Interviews Exposed: Coding Your Way Through the Interview, 4th Edition - Answers in C++ and Java - This is a good warm-up for Cracking the Coding Interview - Not too difficult. Most problems may be easier than what you'll see in an interview (from what I've read) - Cracking the Coding Interview, 6th Edition - answers in Java If you have tons of extra time: Choose one: - Elements of Programming Interviews (C++ version) - Elements of Programming Interviews in Python - Elements of Programming Interviews (Java version) - Companion Project - Method Stub and Test Cases for Every Problem in the Book ⬆ back to top Don't Make My Mistakes This list grew over many months, and yes, it got out of hand. Here are some mistakes I made so you'll have a better experience. And you'll save months of time. 1. You Won't Remember it All I watched hours of videos and took copious notes, and months later there was much I didn't remember. I spent 3 days going through my notes and making flashcards, so I could review. I didn't need all of that knowledge. Please, read so you won't make my mistakes: Retaining Computer Science Knowledge. 2. Use Flashcards To solve the problem, I made a little flashcard site where I could add flashcards of 2…", "metadata": {"source": "github_readme", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.364, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.364}}
{"format": "sequential_text", "title": "yangshun/tech-interview-handbook", "text": "Tech Interview Handbook Topics marked with ✅ have all their problems completed; those without the mark still have problems left to solve. Array String ✅ Two Pointers ✅ Linked List ✅ Stack Tree Dynamic programming ✅ Backtracking Depth First Search Breadth First Search Binary Search Math Hash Table ✅ Sort ✅ Bit Manipulation ✅ Union Find ✅ Sliding Window ✅ Segment Tree ✅ Binary Indexed Tree | Data Structure | Variants | Related Problems | Articles | |:-------:|:-------|:------|:------| |Sequential list: vector|||| |Singly linked list|1. Doubly linked list 2. Static linked list 3. Symmetric matrix 4. Sparse matrix||| |Hash table|1. Hash functions 2. Collision resolution / load factor ||| |Stack and queue|1. Generalized stack 2. Deque ||| |Queue|1. Linked-list implementation 2. Circular-array implementation 3. Deque||| |String|1. KMP algorithm 2. Finite-state automaton 3. Pattern-matching finite-state automaton 4. Boyer-Moore (BM) algorithm 5. BM-KMP algorithm 6. Brute-force (BF) algorithm||| |Tree|1. Binary tree 2. Union-Find (disjoint set) 3. Huffman tree||| |Array-based heap|1. Max-heap and min-heap 2. Min-max heap 3. Double-ended heap (deap) 4. d-ary heap||| |Tree-based heap|1. Leftist heap 2. Skew heap 3. Binomial heap 4. Fibonacci heap 5. Pairing heap||| |Search|1. Hash table 2. Skip list 3. Binary search tree 4. AVL tree 5. B-tree / B+ tree / B tree 6. AA tree 7. Red-black tree 8. Sorted binary heap 9. Splay tree 10. Double-chained tree 11. Trie 12. R-tree||| Algorithm | Algorithm | Specific Types | Related Problems | Articles | |:-------:|:-------|:------|:------| |Sorting algorithms|1. Bubble sort 2. Insertion sort 3. Selection sort 4. Shell sort 5. Quicksort 6. Merge sort 7. Heap sort 8. Linear-time sorting 9. Introsort 10. Indirect sort 11. Counting sort 12. Radix sort 13. Bucket sort 14. External sort - k-way merge with a loser tree 15. External sort - optimal merge tree||| |Recursion & divide and conquer||1. Binary search 2. Multiplication of large integers 3. Strassen's matrix multiplication 4. Chessboard covering 5. Merge sort 6. Quicksort 7. Linear-time selection 8. Closest pair of points 9. Round-robin tournament scheduling || |Dynamic programming||1. Matrix-chain multiplication 2. Longest common subsequence 3. Maximum subarray sum 4. Optimal triangulation of a convex polygon 5. The polygon game 6. Image compression 7. Circuit wiring 8. Flow-shop scheduling 9. 0-1 knapsack / the \"nine knapsack lectures\" 10. Optimal binary search tree 11. DP speed-up principles 12. Tree DP || |Greedy||1. Activity-selection problem 2. Optimal loading 3. Huffman coding 4. Single-source shortest paths 5. Minimum spanning tree 6. Multi-machine scheduling || |Backtracking||1. Loading problem 2. Batch-job scheduling 3. Sign-of-triangle problem 4. n-queens problem 5. 0-1 knapsack 6. Maximum-clique problem 7. Graph m-coloring problem 8. Traveling-salesman problem 9. Circle-arrangement problem 10. Circuit-board placement problem 11. Consecutive-postage problem || |Search|1. Enumeration 2. DFS 3. BFS 4. Heuristic search ||| |Randomization|1. Random numbers 2. Numerical randomized algorithms 3. Sherwood algorithm 4. Las Vegas algorithm 5. Monte Carlo algorithm |1. Computing the value of π 2. Computing definite integrals 3. Solving nonlinear systems 4. Linear-time selection 5. Skip list 6. n-queens problem 7. Integer factorization 8. Majority-element problem 9. Primality testing || |Graph theory|1. Traversal: DFS / BFS 2. AOV / AOE networks 3. Kruskal's algorithm (MST) 4. Prim's algorithm (MST) 5. Borůvka's algorithm (MST) 6. Dijkstra's algorithm (single-source shortest path) 7. Bellman-Ford algorithm (single-source shortest path) 8. SPFA algorithm (single-source shortest path) 9. Floyd algorithm (all-pairs shortest path) 10. Johnson's algorithm (all-pairs shortest path) 11. Fleury's algorithm (Eulerian circuit) 12. Ford-Fulkerson algorithm (max-flow augmenting path) 13. Edmonds-Karp algorithm (max flow) 14. Dinic's algorithm (max flow) 15. Generic push-relabel algorithm 16. Highest-label push-relabel (HLPP) algorithm 17. Primal-Dual algorithm (min-cost flow)18. Kosaraju's algorithm (strongly connected components) 19. Tarjan's algorithm (strongly connected components) 20. Gabow's algorithm (strongly connected components) 21. Hungarian algorithm (bipartite matching) 22. Hopcroft-Karp algorithm (bipartite matching) 23. Kuhn-Munkres algorithm (optimal bipartite matching) 24. Edmonds' Blossom-Contraction algorithm (general graph matching) |1. Graph traversal 2. Strong/weak connectivity of directed and undirected graphs 3. Cut vertices / cut edges 3. AOV networks and topological sorting 4. AOE networks and the critical path 5. Minimum-cost spanning tree / second-best MST 6. Shortest-path problem / K-th shortest path 7. Maximum-flow problem 8. Minimum-cost flow problem 9. Graph-coloring problem 10. System of difference constraints 11. Eulerian circuit 12. Chinese postman problem 13. Hamiltonian cycle 14. Best edge/vertex cut set / minimum edge/vertex cut set / minimum path cover / minimum vertex cover 15. Edge cover set 16. Bipartite perfect matching and maximum matching 17. Cactus graph 18. Chordal graph 19. Stable-marriage problem 20. Maximum-clique problem || |Number theory||1. Greatest common divisor 2. Least common multiple 3. Prime factorization 4. Primality testing 5. Base conversion 6. Arbitrary-precision arithmetic 7. Divisibility 8. Congruences 9. Euler's totient function 10. Extended Euclidean algorithm 11. Permutation groups 12. Generating functions 13. Discrete transforms 14. Cantor expansion 15. Matrices 16. Vectors 17. Systems of linear equations 18. Linear programming || |Geometry||1. Convex hull - gift wrapping 2. Convex hull - Graham scan 3. Line-segment problems 4. Problems on polygons and polyhedra || |NP-completeness|1. Computation models 2. Class-P and class-NP problems 3. NP-complete problems 4. Approximation algorithms for NP-complete problems |1. Random-access machine (RAM) 2. Random-access stored-program machine (RASP) 3. Turing machine 4. Non-deterministic Turing machine 5. Class-P and class-NP languages 6. Polynomial-time verification 7. Polynomial-time reduction 8. Cook's theorem 9. CNF satisfiability (CNF-SAT) 10. 3-CNF satisfiability (3-SAT) 11. Clique problem (CLIQUE) 12. Vertex-cover problem (VERTEX-COVER) 13. Subset-sum problem (SUBSET-SUM) 14. Hamiltonian-cycle problem (HAM-CYCLE) 15. Traveling-salesman problem (TSP) 16. Approximation algorithm for vertex cover 17. Approximation algorithm for TSP 18. TSP with the triangle inequality 19. General TSP 20. Approximation algorithm for set cover 21. Approximation algorithm for subset sum 22. Exponential-time algorithm for subset sum 23. Polynomial-time approximation scheme for subset sum || LeetCode Problems 1. Personal Stats | | Easy | Medium | Hard | Total | |:--------:|:--------:|:--------:|:--------:|:--------:| |Optimizing|31|78|43|152| |Accepted|287|484|142|913| |Total|600|1305|539|2444| |Perfection Rate|89.2%|83.9%|69.7%|83.4%| |Completion Rate|47.8%|37.1%|26.3%|37.4%| 2. Directory 787 problems already have solutions here; another 11 are still being optimized toward beats 100%. | No. | Title | Solution | Acceptance | Difficulty | Frequency | |:--------:|:--------------------------------------------------------------|:--------:|:--------:|:--------:|:--------:| |0001|Two Sum|Go|49.1%|Easy|| |0002|Add Two Numbers|Go|39.7%|Medium|| |0003|Longest Substring Without Repeating Characters|Go|33.8%|Medium|| |0004|Median of Two Sorted Arrays|Go|35.1%|Hard|| |0005|Longest Palindromic Substring|Go|32.4%|Medium|| |0006|Zigzag Conversion|Go|43.0%|Medium|| |0007|Reverse Integer|Go|27.2%|Medium|| |0008|String to Integer (atoi)|Go|16.6%|Medium|| |0009|Palindrome Number|Go|52.8%|Easy|| |0010|Regular Expression Matching||28.3%|Hard|| |0011|Container With Most Water|Go|54.3%|Medium|| |0012|Integer to Roman|Go|60.5%|Medium|| |0013|Roman to Integer|Go|58.2%|Easy|| |0014|Longest Common Prefix|Go|40.7%|Easy|| |0015|3Sum|Go|32.2%|Medium|| |0016|3Sum Closest|Go|46.2%|Medium|| |0017|Letter Combinations of a Phone Number|Go|55.5%|Medium|| |0018|4Sum|Go|36.5%|Medium|| |0019|Remove Nth Node From End of List|Go|39.9%|Medium|| |0020|Valid Parentheses|Go|40.7%|Easy|| |0021|Merge Two Sorted Lists|Go|61.8%|Easy|| |0022|Generate Parentheses|Go|71.7%|Medium|| |0023|Merge k Sorted Lists|Go|48.3%|Hard|| |0024|Swap Nodes in Pairs|Go|60.3%|Medium|| |0025|Reverse Nodes in k-Group|Go|53.4%|Hard|| |0026|Remove Duplicates from Sorted Array|Go|50.3%|Easy|| |0027|Remove Element|Go|52.0%|Easy|| |0028|Find the Index of the First Occurrence in a String|Go|37.4%|Medium|| |0029|Divide Two Integers|Go|17.4%|Medium|| |0030|Substring with Concatenation of All Words|Go|30.9%|Hard|| |0031|Next Permutation|Go|37.1%|Medium|| |0032|Longest Valid Parentheses|Go|32.7%|Hard|| |0033|Search in Rotated Sorted Array|Go|38.6%|Medium|| |0034|Find First and Last Position of Element in Sorted Array|Go|41.5%|Medium|| |0035|Search Insert Position|Go|42.0%|Easy|| |0036|Valid Sudoku|Go|56.7%|Medium|| |0037|Sudoku Solver|Go|56.6%|Hard|| |0038|Count and Say||51.1%|Medium|| |0039|Combination Sum|Go|67.5%|Medium|| |0040|Combination Sum II|Go|53.3%|Medium|| |0041|First Missing Positive|Go|36.5%|Hard|| |0042|Trapping Rain Water|Go|58.7%|Hard|| |0043|Multiply Strings|Go|38.7%|Medium|| |0044|Wildcard Matching||26.8%|Hard|| |0045|Jump Game II|Go|38.5%|Medium|| |0046|Permutations|Go|74.6%|Medium|| |0047|Permutations II|Go|56.6%|Medium|| |0048|Rotate Image|Go|69.8%|Medium|| |0049|Group Anagrams|Go|65.9%|Medium|| |0050|Pow(x, n)|Go|32.8%|Medium|| |0051|N-Queens|Go|62.8%|Hard|| |0052|N-Queens II|Go|70.8%|Hard|| |0053|Maximum Subarray|Go|50.0%|Medium|| |0054|Spiral Matrix|Go|43.6%|Medium|| |0055|Jump Game|Go|38.4%|Medium|| |0056|Merge Intervals|Go|45.9%|Medium|| |0057|Insert Interval|Go|37.9%|Medium|| |0058|Length of Last Word|Go|40.3%|Easy|| |0059|Spiral Matrix II|Go|66.5%|Medium|| |0060|Permutation Sequence|Go|43.7%|Hard|| |0061|Rotate List|Go|35.7%|Medium|| |0062|Unique Paths|Go|62.2%|Medium|| |0063|Unique Paths II|Go|39.1%|Medium|| |0064|Minimum Path Sum|Go|60.6%|Medium|| |0065|Valid Number|Go|18.6%|Hard|| |0066|Plus One|Go|43.3%|Easy|| |0067|Add Binary|Go|51.3%|Easy|| |0068|Text Justification||36.6%|Hard|| |0069|Sqrt(x)|Go|37.0%|Easy|| |0070|Climbing Stairs|Go|51.7%|Easy|| |0071|Simplify Path|Go|39.2%|Medium|| |0072|Edit Distance||52.6%|Hard|| |0073|Set Matrix Zeroes|Go|49.9%|Medium|| |0074|Search a 2D Matrix|Go|46.7%|Medium|| |0075|Sort Colors|Go|57.1%|Medium|| |0076|Minimum Window Substring|Go|40.0%|Hard|| |0077|Combinations|Go|66.0%|Medium|| |0078|Subsets|Go|73.7%|Medium|| |0079|Word Search|Go|39.8%|Medium|| |0080|Remove Duplicates from Sorted Array II|Go|51.5%|Medium|| |0081|Search in…", "metadata": {"source": "github_readme", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.354, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.354}}
{"format": "sequential_text", "title": "kodecocodes/swift-algorithm-club", "text": "Welcome to the Swift Algorithm Club! Here you'll find implementations of popular algorithms and data structures in everyone's favorite new language Swift, with detailed explanations of how they work. If you're a computer science student who needs to learn this stuff for exams -- or if you're a self-taught programmer who wants to brush up on the theory behind your craft -- you've come to the right place! The goal of this project is to explain how algorithms work. The focus is on clarity and readability of the code, not on making a reusable library that you can drop into your own projects. That said, most of the code should be ready for production use but you may need to tweak it to fit into your own codebase. Code is compatible with Xcode 10 and Swift 4.2. We'll keep this updated with the latest version of Swift. If you're interested in a GitHub pages version of the repo, check out this. :heart_eyes: Suggestions and contributions are welcome! :heart_eyes: Important links What are algorithms and data structures? Pancakes! Why learn algorithms? Worried this isn't your cup of tea? Then read this. Big-O notation. We often say things like, \"This algorithm is O(n).\" If you don't know what that means, read this first. Algorithm design techniques. How do you create your own algorithms? How to contribute. Report an issue to leave feedback, or submit a pull request. Where to start? If you're new to algorithms and data structures, here are a few good ones to start out with: - Stack - Queue - Insertion Sort - Binary Search and Binary Search Tree - Merge Sort - Boyer-Moore string search The algorithms Searching - Linear Search. Find an element in an array. - Binary Search. Quickly find elements in a sorted array. - Count Occurrences. Count how often a value appears in an array. - Select Minimum / Maximum. Find the minimum/maximum value in an array. - k-th Largest Element. Find the k-th largest element in an array, such as the median. - Selection Sampling. Randomly choose a bunch of items from a collection. - Union-Find. Keeps track of disjoint sets and lets you quickly merge them. String Search - Brute-Force String Search. A naive method. - Boyer-Moore. A fast method to search for substrings. It skips ahead based on a look-up table, to avoid looking at every character in the text. - Knuth-Morris-Pratt. A linear-time string algorithm that returns indexes of all occurrencies of a given pattern. - Rabin-Karp Faster search by using hashing. - Longest Common Subsequence. Find the longest sequence of characters that appear in the same order in both strings. - Z-Algorithm. Finds all instances of a pattern in a String, and returns the indexes of where the pattern starts within the String. Sorting It's fun to see how sorting algorithms work, but in practice you'll almost never have to provide your own sorting routines. Swift's own sort() is more than up to the job. But if you're curious, read on... Basic sorts: - Insertion Sort - Selection Sort - Shell Sort Fast sorts: - Quicksort - Merge Sort - Heap Sort Hybrid sorts: - Introsort Special-purpose sorts: - Counting Sort - Radix Sort - Topological Sort Bad sorting algorithms (don't use these!): - Bubble Sort - Slow Sort Compression - Run-Length Encoding (RLE). Store repeated values as a single byte and a count. - Huffman Coding. Store more common elements using a smaller number of bits. Miscellaneous - Shuffle. Randomly rearranges the contents of an array. - Comb Sort. An improve upon the Bubble Sort algorithm. - Convex Hull. - Miller-Rabin Primality Test. Is the number a prime number? - MinimumCoinChange. A showcase for dynamic programming. - Genetic. A simple example on how to slowly mutate a value to its ideal form, in the context of biological evolution. - Myers Difference Algorithm. Finding the longest common subsequence of two sequences. Mathematics - Greatest Common Divisor (GCD). Special bonus: the least common multiple. - Permutations and Combinations. Get your combinatorics on! - Shunting Yard Algorithm. Convert infix expressions to postfix. - Karatsuba Multiplication. Another take on elementary multiplication. - Haversine Distance. Calculating the distance between 2 points from a sphere. - Strassen's Multiplication Matrix. Efficient way to handle matrix multiplication. - CounterClockWise. Determining the area of a simple polygon. Machine learning - k-Means Clustering. Unsupervised classifier that partitions data into k clusters. - k-Nearest Neighbors - Linear Regression. A technique for creating a model of the relationship between two (or more) variable quantities. - Logistic Regression - Neural Networks - PageRank - Naive Bayes Classifier - Simulated annealing. Probabilistic technique for approximating the global maxima in a (often discrete) large search space. Data structures The choice of data structure for a particular task depends on a few things. First, there is the shape of your data and the kinds of operations that you'll need to perform on it. If you want to look up objects by a key you need some kind of dictionary; if your data is hierarchical in nature you want a tree structure of some sort; if your data is sequential you want a stack or queue. Second, it matters what particular operations you'll be performing most, as certain data structures are optimized for certain actions. For example, if you often need to find the most important object in a collection, then a heap or priority queue is more optimal than a plain array. Most of the time using just the built-in Array, Dictionary, and Set types is sufficient, but sometimes you may want something more fancy... Variations on arrays - Array2D. A two-dimensional array with fixed dimensions. Useful for board games. - Bit Set. A fixed-size sequence of n bits. - Fixed Size Array. When you know beforehand how large your data will be, it might be more efficient to use an old-fashioned array with a fixed size. - Ordered Array. An array that is always sorted. - Rootish Array Stack. A space and time efficient variation on Swift arrays. Queues - Stack. Last-in, first-out! - Queue. First-in, first-out! - Deque. A double-ended queue. - Priority Queue. A queue where the most important element is always at the front. - Ring Buffer. Also known as a circular buffer. An array of a certain size that conceptually wraps around back to the beginning. Lists - Linked List. A sequence of data items connected through links. Covers both singly and doubly linked lists. - Skip-List. Skip List is a probabilistic data-structure with same logarithmic time bound and efficiency as AVL/ or Red-Black tree and provides a clever compromise to efficiently support search and update operations. Trees - Tree. A general-purpose tree structure. - Binary Tree. A tree where each node has at most two children. - Binary Search Tree (BST). A binary tree that orders its nodes in a way that allows for fast queries. - Red-Black Tree. A self balancing binary search tree. - Splay Tree. A self balancing binary search tree that enables fast retrieval of recently updated elements. - Threaded Binary Tree. A binary tree that maintains a few extra variables for cheap and fast in-order traversals. - Segment Tree. Can quickly compute a function over a portion of an array. - Lazy Propagation - kd-Tree - Sparse Table. Another take on quickly computing a function over a portion of an array, but this time we'll make it even quicker!. - Heap. A binary tree stored in an array, so it doesn't use pointers. Makes a great priority queue. - Fibonacci Heap - Trie. A special type of tree used to store associative data structures. - B-Tree. A self-balancing search tree, in which nodes can have more than two children. - QuadTree. A tree with 4 children. - Octree. A tree with 8 children. Hashing - Hash Table. Allows you to store and retrieve objects by a key. This is how the dictionary type is usually implemented. - Hash Functions Sets - Bloom Filter. A constant-memory data structure that probabilistically tests whether an element is in a set. - Hash Set. A set implemented using a hash table. - Multiset. A set where the number of times an element is added matters. (Also known as a bag.) - Ordered Set. A set where the order of items matters. Graphs - Graph - Breadth-First Search (BFS) - Depth-First Search (DFS) - Shortest Path on an unweighted tree - Single-Source Shortest Paths/) - Minimum Spanning Tree on an unweighted tree - Minimum Spanning Tree - All-Pairs Shortest Paths - Dijkstra's shortest path algorithm - A-Star Puzzles A lot of software developer interview questions consist of algorithmic puzzles. Here is a small selection of fun ones. For more puzzles (with answers), see here and here. - Two-Sum Problem - Three-Sum/Four-Sum Problem - Fizz Buzz - Monty Hall Problem - Finding Palindromes - Dining Philosophers - Egg Drop Problem - Encoding and Decoding Binary Tree - Closest Pair Learn more! Like what you see? Check out Data Structures & Algorithms in Swift, the official book by the Swift Algorithm Club team! You’ll start with the fundamental structures of linked lists, queues and stacks, and see how to implement them in a highly Swift-like way. Move on to working with various types of trees, including general purpose trees, binary trees, AVL trees, binary search trees, and tries. Go beyond bubble and insertion sort with better-performing algorithms, including mergesort, radix sort, heap sort, and quicksort. Learn how to construct directed, non-directed and weighted graphs to represent many real-world models, and traverse graphs and trees efficiently with breadth-first, depth-first, Dijkstra’s and Prim’s algorithms to solve problems such as finding the shortest path or lowest cost in a network. By the end of this book, you’ll have hands-on experience solving common issues with data structures and algorithms — and you’ll be well on your way to developing your own efficient and useful implementations! You can find the book on the raywenderlich.com store. Credits The Swift Algorithm Club was originally created by Matthijs Hollemans. It is now maintained by Vincent Ngo, Kelvin Lau, and Richard Ash. The Swift Algorithm Club is a collaborative effort from the most algorithmic members of the raywenderlich.com community. We're always looking for help - why not join the club? :] License All content is licensed under the terms of the MIT open source license. By posting here, or by submitting any pull request through this forum, you agree that all content you submit or create, both code and text, is subject to this license. Razeware, LLC, and others will have all the rights described in the license regarding this content. The precise terms of this license may be found here.", "metadata": {"source": "github_readme", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "apache/superset", "text": "Superset A modern, enterprise-ready business intelligence web application. Documentation - User Guide — For analysts and business users. Explore data, build charts, create dashboards, and connect databases. - Administrator Guide — Install, configure, and operate Superset. Covers security, scaling, and database drivers. - Developer Guide — Contribute to Superset or build on its REST API and extension framework. Why Superset? | Supported Databases | Release Notes | Get Involved | Resources | Organizations Using Superset Why Superset? Superset is a modern data exploration and data visualization platform. Superset can replace or augment proprietary business intelligence tools for many teams. Superset integrates well with a variety of data sources. Superset provides: - A no-code interface for building charts quickly - A powerful, web-based SQL Editor for advanced querying - A lightweight semantic layer for quickly defining custom dimensions and metrics - Out of the box support for nearly any SQL database or data engine - A wide array of beautiful visualizations to showcase your data, ranging from simple bar charts to geospatial visualizations - Lightweight, configurable caching layer to help ease database load - Highly extensible security roles and authentication options - An API for programmatic customization - A cloud-native architecture designed from the ground up for scale Screenshots & Gifs Video Overview superset-video-1080p.webm Large Gallery of Visualizations 🙌 Become a Sponsor You can support this project by becoming a sponsor on GitHub Sponsors or through PayPal. Every contribution, big or small, makes a huge difference. Thank you for your support! 🌟 30 Days Of Python: Day 1 - Introduction >> and then click Enter. Let us write our very first script on the Python scripting shell. Well done, you wrote your first Python script on Python interactive shell. How do we close the Python interactive shell ? To close the shell, next to this symbol >>> write exit() command and press Enter. Now, you know how to open the Python interactive shell and how to exit from it. Python will give you results if you write scripts that Python understands, if not it returns errors. Let's make a deliberate mistake and see what Python will return. As you can see from the returned error, Python is so clever that it knows the mistake we made and which was _Syntax Error: invalid syntax_. Using x as multiplication in Python is a syntax error because (x) is not a valid syntax in Python. Instead of (x) we use asterisk () for multiplication. The returned error clearly shows what to fix. The process of identifying and removing errors from a program is called _debugging_. Let us debug it by putting in place of x. Our bug was fixed, the code ran and we got a result we were expecting. As a programmer you will see such kind of errors on daily basis. It is good to know how to debug. To be good at debugging you should understand what kind of errors you are facing. Some of the Python errors you may encounter are _SyntaxError_, _IndexError_, _NameError_, _ModuleNotFoundError_, _KeyError_, _ImportError_, _AttributeError_, _TypeError_, _ValueError_, _ZeroDivisionError_ etc. We will see more about different Python _error types_ in later sections. Let us practice more how to use Python interactive shell. Go to your terminal or command prompt and write the word python. The Python interactive shell is opened. Let us do some basic mathematical operations (addition, subtraction, multiplication, division, modulus, exponentiation). Let us do some maths first before we write any Python code: - 2 + 3 = 5 - 3 - 2 = 1 - 3 \\ 2 = 6 - 3 / 2 = 1.5 - 3 \\\\ 2 = 3 x 3 = 9 In python, we have the following additional operations: - 3 % 2 = 1 => which means finding the remainder - 3 // 2 = 1 => which means removing the remainder Let us change the above mathematical expressions to Python code. The Python shell has been opened and let us write a comment at the very beginning of the shell. A _comment_ is a part of the code which is not executed by python. So we can leave some text in our code to make our code more readable. Python does not run the comment part. A comment in python starts with hash(#) symbol. This is how you write a comment in python Before we move on to the next section, let us practice more on the Python interactive shell. Close the opened shell by writing _exit()_ on the shell and open it again and let us practice how to write text on the Python shell. Installing Visual Studio Code The Python interactive shell is good to try and test small script codes but it will not be for a big project. In real work environment, developers use different code editors to write codes. In this 30 days of Python programming challenge, we will use Visual Studio Code. Visual Studio Code is a very popular open source text editor. I am a fan of vscode and I would recommend to download visual studio code, but if you are in favor of other editors, feel free to follow with what you have. If you installed visual studio code, let us see how to use it. If you prefer a video, you can follow this Visual Studio Code for Python Video tutorial How to use visual studio code Open the visual studio code by double clicking the visual studio icon. When you open it you will get this kind of interface. Try to interact with the labeled icons. Create a folder named 30DaysOfPython on your desktop. Then open it using visual studio code. After opening it, you will see shortcuts for creating files and folders inside of 30DaysOfPython project's directory. As you can see below, I have created the very first file, helloworld.py. You can do the same. After a long day of coding, you want to close your code editor, right? This is how you will close the opened project. Congratulations, you have finished setting up the development environment. Let us start coding. Basic Python Python Syntax A Python script can be written in Python interactive shell or in the code editor. A Python file has an extension .py. Python Indentation An indentation is a white space in a text. Indentation in many languages is used to increase code readability; however, Python uses indentation to create blocks of code. In other programming languages, curly brackets are used to create code blocks instead of indentation. One of the common bugs when writing Python code is incorrect indentation. Comments Comments play a crucial role in enhancing code readability and allowing developers to leave notes within their code. In Python, any text preceded by a hash (#) symbol is considered a comment and is not executed when the code runs. Example: Single Line Comment Example: Multiline Comment Triple quote can be used for multiline comment if it is not assigned to a variable Data types In Python there are several types of data types. Let us get started with the most common ones. Different data types will be covered in detail in other sections. For the time being, let us just go through the different data types and get familiar with them. You do not have to have a clear understanding now. Number - Integer: Integer(negative, zero and positive) numbers Example: ... -3, -2, -1, 0, 1, 2, 3 ... - Float: Decimal number Example ... -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 ... - Complex Example 1 + j, 2 + 4j String A collection of one or more characters under a single or double quote. If a string is more than one sentence then we use a triple quote. Example: Booleans A boolean data type is either a True or False value. T and F should be always uppercase. Example: List Python list is an ordered collection which allows to store different data type items. A list is similar to an array in JavaScript. Example: Dictionary A Python dictionary object is an unordered collection of data in a key value pair format. Example: Tuple A tuple is an ordered collection of different data types like list but tuples can not be modified once they are created. They are immutable. Example: Set A set is a collection of data types similar to list and tuple. Unlike list and tuple, set is not an ordered collection of items. Like in Mathematics, set in Python…", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.392, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": true, "code_ok": false, "math_checked": true, "math_ok": true, "verified": false, "confidence_weight": 0.092}}
{"format": "sequential_text", "title": "pandas-dev/pandas", "text": " [!TIP] > It is best to install Gradio in a virtual environment. Detailed installation instructions for all common operating systems [!TIP] > We shorten the imported name from gradio to gr . This is a widely adopted convention for better readability of code. Now, run your code. If you've written the Python code in a file named app.py, then you would run python app.py from the terminal. The demo below will open in a browser on if running from a file. If you are running within a notebook, the demo will appear embedded within the notebook. Type your name in the textbox on the left, drag the slider, and then press the Submit button. You should see a friendly greeting on the right. > [!TIP] > When developing locally, you can run your Gradio app in hot reload mode , which automatically reloads the Gradio app whenever you make changes to the file. To do this, simply type in gradio before the name of the file instead of python . In the example above, you would type: gradio app.py in your terminal. You can also enable vibe mode by using the --vibe flag, e.g. gradio --vibe app.py , which provides an in-browser chat that can be used to write or edit your Gradio app using natural language. Learn more in the [!TIP] > For the inputs and outputs arguments, you can pass in the name of these components as a string (\"textbox\") or an instance of the class (gr.Textbox()). If your function accepts more than one argument, as is the case above, pass a list of input components to inputs, with each input component corresponding to one of the arguments of the function, in order. The same holds true if your function returns more than one value: simply pass in a list of components to outputs. This flexibility makes the Interface class a very powerful way to create demos. We'll dive deeper into the gr.Interface on our series on building Interfaces. Sharing Your Demo What good is a beautiful demo if you can't share it? Gradio lets you easily share a machine learning demo without having to worry about the hassle of hosting on a web server. Simply set share=True in launch(), and a publicly accessible URL will be created for your demo. Let's revisit our example demo, but change the last line as follows: When you run this code, a public URL will be generated for your demo in a matter of seconds, something like: 👉 Now, anyone around the world can try your Gradio demo from their browser, while the machine learning model and all computation continues to run locally on your computer. To learn more about sharing your demo, read our dedicated guide on sharing your Gradio application. An Overview of Gradio So far, we've been discussing the Interface class, which is a high-level class that lets you build demos quickly with Gradio. But what else does Gradio include? Custom Demos with gr.Blocks Gradio offers a low-level approach for designing web apps with more customizable layouts and data flows with the gr.Blocks class. Blocks supports things like controlling where components appear on the page, handling multiple data flows and more complex interactions (e.g. outputs can serve as inputs to other functions), and updating properties/visibility of components based on user interaction — still all in Python. You can build very custom and complex applications using gr.Blocks(). For example, the popular image generation Automatic1111 Web UI is built using Gradio Blocks. We dive deeper into the gr.Blocks on our series on building with Blocks. Chatbots with gr.ChatInterface Gradio includes another high-level class, gr.ChatInterface, which is specifically designed to create Chatbot UIs. Similar to Interface, you supply a function and Gradio creates a fully working Chatbot UI. If you're interested in creating a chatbot, you can jump straight to our dedicated guide on gr.ChatInterface. The Gradio Python & JavaScript Ecosystem That's the gist of the core gradio Python library, but Gradio is actually so much more! It's an entire ecosystem of Python and JavaScript libraries that let you build machine learning applications, or query them programmatically, in Python or JavaScript. Here are other related parts of the Gradio ecosystem: Gradio Python Client (gradio_client): query any Gradio app programmatically in Python. Gradio JavaScript Client (@gradio/client): query any Gradio app programmatically in JavaScript. Hugging Face Spaces: the most popular place to host Gradio applications — for free! Server mode (gradio.Server): build a custom frontend with Gradio's backend — queue, streaming, MCP, ZeroGPU, and Spaces hosting included. What's Next? Keep learning about Gradio sequentially using the Gradio Guides, which include explanations as well as example code and embedded interactive demos. Next up: let's dive deeper into the Interface class. Or, if you already know the basics and are looking for something specific, you can search the more technical API documentation. AI Coding Skills Gradio provides a \"skill\" that enriches AI coding assistants (like Cursor, Claude Code, Codex, etc.) with Gradio-specific knowledge, so that they can build Gradio apps more effectively. This is especially useful when creating custom Gradio components or styling. Install the Gradio skill for coding assistants with a single command: This installs to the shared .agents/skills directory used by Codex, Cursor, OpenCode, and other compatible agents. Use --global to install at the user level (applies to all projects), or an agent flag such as --claude` to also create a link in that agent's skills directory. You can also install a skill for a specific Gradio Space, which generates API usage docs (Python, JS, cURL) on the fly: Questions? If you'd like to report a bug or have a feature request, please create an issue on GitHub. For general questions about usage, we are available on our Discord server and happy to help. If you like Gradio, please leave us a ⭐ on GitHub! Open Source Stack Gradio is built on top of many wonderful open-source libraries! License Gradio is licensed under the Apache License 2.0 found in the LICENSE file in the root directory of this repository. Citation Also check out the paper _Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild, ICML HILL 2019_, and please cite it if you use Gradio in your work.", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.365, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.365}}
{"format": "sequential_text", "title": "explosion/spaCy", "text": "spaCy: Industrial-strength NLP spaCy is a library for advanced Natural Language Processing in Python and Cython. It's built on the very latest research, and was designed from day one to be used in real products. spaCy comes with pretrained pipelines and currently supports tokenization and training for 70+ languages. It features state-of-the-art speed and neural network models for tagging, parsing, named entity recognition, text classification and more, multi-task learning with pretrained transformers like BERT, as well as a production-ready training system and easy model packaging, deployment and workflow management. spaCy is commercial open-source software, released under the MIT license. 💫 Version 3.8 out now! Check out the release notes here. 📖 Documentation | Documentation | | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ⭐️ [spaCy 101] | New to spaCy? Here's everything you need to know! | | 📚 [Usage Guides] | How to use spaCy and its features. | | 🚀 [New in v3.0] | New features, backwards incompatibilities and migration guide. | | 🪐 [Project Templates] | End-to-end workflows you can clone, modify and run. | | 🎛 [API Reference] | The detailed reference for spaCy's API. | | ⏩ [GPU Processing] | Use spaCy with CUDA-compatible GPU processing. | | 📦 [Models] | Download trained pipelines for spaCy. | | 🦙 [Large Language Models] | Integrate LLMs into spaCy pipelines. | | 🌌 [Universe] | Plugins, extensions, demos and books from the spaCy ecosystem. | | ⚙️ [spaCy VS Code Extension] | Additional tooling and features for working with spaCy's config files. | | 👩🏫 [Online Course] | Learn spaCy in this free and interactive online course. | | 📰 [Blog] | Read about current spaCy and Prodigy development, releases, talks and more from Explosion. | | 📺 [Videos] | Our YouTube channel with video tutorials, talks and more. | | 🔴 [Live Stream] | Join Matt as he works on spaCy and chat about NLP. | | 🛠 [Changelog] | Changes and version history. | | 💝 [Contribute] | How to contribute to the spaCy project and code base. | | 👕 [Swag] | Support us and our work with unique, custom-designed swag! | | | Custom NLP consulting, implementation and strategic advice by spaCy’s core development team. Streamlined, production-ready, predictable and maintainable. Send us an email or take our 5-minute questionnaire, and well'be in touch! Learn more → | [spacy 101]: [new in v3.0]: [usage guides]: [api reference]: [gpu processing]: [models]: [large language models]: [universe]: [spacy vs code extension]: [videos]: [live stream]: [online course]: [blog]: [project templates]: [changelog]: [contribute]: [swag]: 💬 Where to ask questions The spaCy project is maintained by the spaCy team. Please understand that we won't be able to provide individual support via email. We also believe that help is much more valuable if it's shared publicly, so that more people can benefit from it. | Type | Platforms | | ------------------------------- | --------------------------------------- | | 🚨 Bug Reports | [GitHub Issue Tracker] | | 🎁 Feature Requests & Ideas | [GitHub Discussions] · [Live Stream] | | 👩💻 Usage Questions | [GitHub Discussions] · [Stack Overflow] | | 🗯 General Discussion | [GitHub Discussions] · [Live Stream] | [github issue tracker]: [github discussions]: [stack overflow]: [live stream]: Features - Support for 70+ languages - Trained pipelines for different languages and tasks - Multi-task learning with pretrained transformers like BERT - Support for pretrained word vectors and embeddings - State-of-the-art speed - Production-ready training system - Linguistically-motivated tokenization - Components for named entity recognition, part-of-speech-tagging, dependency parsing, sentence segmentation, text classification, lemmatization, morphological analysis, entity linking and more - Easily extensible with custom components and attributes - Support for custom models in PyTorch, TensorFlow and other frameworks - Built in visualizers for syntax and NER - Easy model packaging, deployment and workflow management - Robust, rigorously evaluated accuracy 📖 For more details, see the facts, figures and benchmarks. ⏳ Install spaCy For detailed installation instructions, see the documentation. - Operating system: macOS / OS X · Linux · Windows (Cygwin, MinGW, Visual Studio) - Python version: Python >=3.7, <3.13 (only 64 bit) - Package managers: [pip] · [conda] (via conda-forge) [pip]: [conda]: pip Using pip, spaCy releases are available as source packages and binary wheels. Before you install spaCy and its dependencies, make sure that your pip, setuptools and wheel are up to date. To install additional data tables for lemmatization and normalization you can run pip install spacy[lookups] or install spacy-lookups-data separately. The lookups package is needed to create blank models with lemmatization data, and to lemmatize in languages that don't yet come with pretrained models and aren't powered by third-party libraries. When using pip it is generally recommended to install packages in a virtual environment to avoid modifying system state: conda You can also install spaCy from conda via the conda-forge channel. For the feedstock including the build recipe and configuration, check out this repository. Updating spaCy Some updates to spaCy may require downloading new statistical models. If you're running spaCy v2.0 or higher, you can use the validate command to check if your installed models are compatible and if not, print details on how to update them: If you've trained your own models, keep in mind that your training and runtime inputs must match. After updating spaCy, we recommend retraining your models with the new version. 📖 For details on upgrading from spaCy 2.x to spaCy 3.x, see the migration guide. 📦 Download model packages Trained pipelines for spaCy can be installed as Python packages. This means that they're a component of your application, just like any other module. Models can be installed using spaCy's download command, or manually by pointing pip to a path or URL. | Documentation | | | -------------------------- | ---------------------------------------------------------------- | | [Available Pipelines] | Detailed pipeline descriptions, accuracy figures and benchmarks. | | [Models Documentation] | Detailed usage and installation instructions. | | [Training] | How to train your own pipelines on your data. | [available pipelines]: [models documentation]: [training]: Loading and using models To load a model, use spacy.load() with the model name or a path to the model data directory. You can also import a model directly via its full name and then call its load() method with no arguments. 📖 For more info and examples, check out the models documentation. ⚒ Compile from source The other way to install spaCy is to clone its GitHub repository and build it from source. That is the common way if you want to make changes to the code base. You'll need to make sure that you have a development environment consisting of a Python distribution including header files, a compiler, pip, virtualenv and git installed. The compiler part is the trickiest. How to do that depends on your system. | Platform | | | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Ubuntu | Install system-level dependencies via apt-get: sudo apt-get install build-essential python-dev git . | | Mac | Install a recent version of XCode, including the so-called \"Command Line Tools\". macOS and OS X ship with Python and git preinstalled. | | Windows | Install a version of the Visual C++ Build Tools or Visual Studio Express that matches the version that was used to compile your Python interpreter. | For more details and instructions, see the documentation on compiling spaCy from source and the quickstart widget to get the right commands for your platform and Python version. To install with extras: 🚦 Run tests spaCy comes with an extensive test suite. In order to run the tests, you'll usually want to clone the repository and build spaCy from source. This will also install the required development dependencies and test utilities defined in the requirements.txt. Alternatively, you can run pytest on the tests from within the installed spacy package. Don't forget to also install the test utilities via spaCy's requirements.txt:", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.382, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.382}}
{"format": "sequential_text", "title": "Lightning-AI/pytorch-lightning", "text": "The deep learning framework to pretrain and finetune AI models. Serving models? Use LitServe to build custom inference servers in pure Python. Quick start • Examples • PyTorch Lightning • Fabric • 90%+ but build delays may show less Current build statuses | System / PyTorch ver. | 1.13 | 2.0 | 2.1 | | :--------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:| | Linux py3.9 \\[GPUs\\] | | | | | Linux (multiple Python versions) | | | | | OSX (multiple Python versions) | | | | | Windows (multiple Python versions) | | | | Community The lightning community is maintained by - 10+ core contributors who are all a mix of professional engineers, Research Scientists, and Ph.D. students from top AI labs. - 800+ community contributors. Want to help us build Lightning and reduce boilerplate for thousands of researchers? Learn how to make your first contribution here Lightning is also part of the PyTorch ecosystem which requires projects to have solid testing, documentation and support. Asking for help If you have any questions please: 1. Read the docs. 1. Search through existing Discussions, or add a new question 1. Join our discord.", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.393, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.393}}
{"format": "sequential_text", "title": "Interactive Deep Learning Book with Code and Discussions", "text": "D2L.ai: Interactive Deep Learning Book with Multi-Framework Code, Math, and Discussions Book website | STAT 157 Course at UC Berkeley The best way to understand deep learning is learning by doing. This open-source book represents our attempt to make deep learning approachable, teaching you the concepts, the context, and the code. The entire book is drafted in Jupyter notebooks, seamlessly integrating exposition figures, math, and interactive examples with self-contained code. Our goal is to offer a resource that could 1. be freely available for everyone; 1. offer sufficient technical depth to provide a starting point on the path to actually becoming an applied machine learning scientist; 1. include runnable code, showing readers how to solve problems in practice; 1. allow for rapid updates, both by us and also by the community at large; 1. be complemented by a forum for interactive discussion of technical details and to answer questions. Universities Using D2L If you find this book useful, please star (★) this repository or cite this book using the following bibtex entry: Endorsements > \"In less than a decade, the AI revolution has swept from research labs to broad industries to every corner of our daily life. Dive into Deep Learning is an excellent text on deep learning and deserves attention from anyone who wants to learn why deep learning has ignited the AI revolution: the most powerful technology force of our time.\" > — Jensen Huang, Founder and CEO, NVIDIA > \"This is a timely, fascinating book, providing with not only a comprehensive overview of deep learning principles but also detailed algorithms with hands-on programming code, and moreover, a state-of-the-art introduction to deep learning in computer vision and natural language processing. Dive into this book if you want to dive into deep learning!\" > — Jiawei Han, Michael Aiken Chair Professor, University of Illinois at Urbana-Champaign > \"This is a highly welcome addition to the machine learning literature, with a focus on hands-on experience implemented via the integration of Jupyter notebooks. Students of deep learning should find this invaluable to become proficient in this field.\" > — Bernhard Schölkopf, Director, Max Planck Institute for Intelligent Systems > \"Dive into Deep Learning strikes an excellent balance between hands-on learning and in-depth explanation. I've used it in my deep learning course and recommend it to anyone who wants to develop a thorough and practical understanding of deep learning.\" > — Colin Raffel, Assistant Professor, University of North Carolina, Chapel Hill Contributing (Learn How) This open source book has benefited from pedagogical suggestions, typo corrections, and other improvements from community contributors. Your help is valuable for making the book better for everyone. Dear D2L contributors, please email your GitHub ID and name to d2lbook.en AT gmail DOT com so your name will appear on the acknowledgments. Thanks. License Summary This open source book is made available under the Creative Commons Attribution-ShareAlike 4.0 International License. See LICENSE file. The sample and reference code within this open source book is made available under a modified MIT license. See the LICENSE-SAMPLECODE file. Chinese version | Discuss and report issues | Code of conduct", "metadata": {"source": "github_readme", "category": "code", "subcategory": "python", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "farion1231/cc-switch", "text": "CC Switch The All-in-One Manager for Claude Code, Claude Desktop, Codex, Gemini CLI, Grok Build, OpenCode, OpenClaw & Hermes Agent 🌐 The Only Official Website: ccswitch.io English | 中文 | 日本語 | Deutsch | Changelog ❤️Sponsor > Want to appear here? Click to collapse Kimi K3 is Moonshot AI's most capable model and the world's first open 3T-class model. With 2.8 trillion parameters, native vision, and a 1-million-token context window, K3 delivers frontier performance across long-horizon coding, knowledge work, and reasoning. CC Switch makes it easy to configure and switch to Kimi across agentic tools. Click here to start using Kimi New user top-up bonus: register via this link and complete your first top-up to receive 10% of the amount as bonus API credit, up to CNY ¥1,000. Doing mostly coding work? Try the Kimi Code subscription. Thanks to PackyCode for sponsoring this project! PackyCode is a reliable and efficient API relay service provider, offering relay services for Claude Code, Codex, Gemini, and more. PackyCode provides special discounts for our software users: register using [!Caution] > Misuse Disclaimer: > The developers of RustDesk do not condone or support any unethical or illegal use of this software. Misuse, such as unauthorized access, control or invasion of privacy, is strictly against our guidelines. The authors are not responsible for any misuse of the application. Chat with us: Discord | Twitter | Reddit | YouTube Yet another remote desktop solution, written in Rust. Works out of the box with no configuration required. You have full control of your data, with no concerns about security. You can use our rendezvous/relay server, set up your own, or write your own rendezvous/relay server. RustDesk welcomes contribution from everyone. See CONTRIBUTING.md for help getting started. FAQ BINARY DOWNLOAD NIGHTLY BUILD Dependencies Desktop versions use Flutter or Sciter (deprecated) for GUI. This tutorial is for Sciter only, since it is easier and more friendly to start. Check out our CI for building the Flutter version. Please download Sciter dynamic library yourself. Windows | Linux | macOS Raw Steps to build - Prepare your Rust development env and C++ build env - Install vcpkg, and set VCPKG_ROOT env variable correctly - Windows: vcpkg install libvpx:x64-windows-static libyuv:x64-windows-static opus:x64-windows-static aom:x64-windows-static - Linux/macOS: vcpkg install libvpx libyuv opus aom - run cargo run Build How to Build on Linux Ubuntu 18 (Debian 10) openSUSE Tumbleweed Fedora 28 (CentOS 8) Arch (Manjaro) Install vcpkg Fix libvpx (For Fedora) Build How to build with Docker Begin by cloning the repository and building the Docker container: Then, each time you need to build the application, run the following command: Note that the first build may take longer before dependencies are cached, subsequent builds will be faster. Additionally, if you need to specify different arguments to the build command, you may do so at the end of the command in the position. For instance, if you wanted to build an optimized release version, you would run the command above followed by --release. The resulting executable will be available in the target folder on your system, and can be run with: Or, if you're running a release executable: Please ensure that you run these commands from the root of the RustDesk repository, or the application may not find the required resources. Also note that other cargo subcommands such as install or run are not currently supported via this method as they would install or run the program inside the container instead of the host. File Structure - libs/hbb_common: video codec, config, tcp/udp wrapper, protobuf, fs functions for file transfer, and some other utility functions - libs/scrap: screen capture - libs/enigo: platform specific keyboard/mouse control - libs/clipboard: file copy and paste implementation for Windows, Linux, macOS. - src/ui: obsolete Sciter UI (deprecated) - src/server: audio/clipboard/input/video services, and network connections - src/client.rs: start a peer connection - src/rendezvous_mediator.rs: Communicate with rustdesk-server, wait for remote direct (TCP hole punching) or relayed connection - src/platform: platform specific code - flutter: Flutter code for desktop and mobile Screenshots", "metadata": {"source": "github_readme", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "rust-lang/rust", "text": " Full explanation: How RTK Savings Work Installation Homebrew (recommended) Quick Install (Linux/macOS) > Installs to ~/.local/bin. Add to PATH if needed: > Cargo Pre-built Binaries Download from releases: - macOS: rtk-x86_64-apple-darwin.tar.gz / rtk-aarch64-apple-darwin.tar.gz - Linux: rtk-x86_64-unknown-linux-musl.tar.gz / rtk-aarch64-unknown-linux-gnu.tar.gz - Windows: rtk-x86_64-pc-windows-msvc.zip > Windows users: Extract the zip and place rtk.exe somewhere in your PATH (e.g. C:\\Users\\ \\.local\\bin). Run RTK from Command Prompt, PowerShell, or Windows Terminal — do not double-click the .exe (it will flash and close). The full hook system works natively on Windows (and in WSL). See Windows setup below for details. Verify Installation > Name collision warning: Another project named \"rtk\" (Rust Type Kit) exists on crates.io. If rtk gain fails, you have the wrong package. Use cargo install --git above instead. Quick Start Hook-based agents rewrite Bash commands (e.g., git status -> rtk git status) before execution. Plugin-based agents, including Hermes, use their plugin API to rewrite commands before execution. The agent receives compact output without needing to call rtk explicitly. Important: the hook only runs on Bash tool calls. Claude Code built-in tools like Read, Grep, and Glob do not pass through the Bash hook, so they are not auto-rewritten. To get RTK's compact output for those workflows, use shell commands (cat/head/tail, rg/grep, find) or call rtk read, rtk grep, or rtk find directly. How It Works Four strategies applied per command type: 1. Smart Filtering - Removes noise (comments, whitespace, boilerplate) 2. Grouping - Aggregates similar items (files by directory, errors by type) 3. Truncation - Keeps relevant context, cuts redundancy 4. Deduplication - Collapses repeated log lines with counts Commands > Percentages below are reductions in bash output, not reductions in your bill. See How Savings Work. Files Git GitHub CLI Test Runners Build & Lint Package Managers AWS Containers Infrastructure as Code Data & Analytics Token Savings Analytics Global Flags Examples Directory listing: Git operations: Test output: Auto-Rewrite Hook The most effective way to use rtk. The hook transparently intercepts Bash commands and rewrites them to rtk equivalents before execution. Result: 100% rtk adoption across all conversations and subagents, with no per-command context overhead. Scope note: this only applies to Bash tool calls. Claude Code built-in tools such as Read, Grep, and Glob bypass the hook, so use shell commands or explicit rtk commands when you want RTK filtering there. Setup After install, restart Claude Code. Windows RTK works fully on native Windows. Since v0.37.2 the auto-rewrite hook runs as a native binary command (rtk hook claude) — no Unix shell, bash, or jq required — so commands are rewritten transparently on Command Prompt, PowerShell, and Windows Terminal, just like on Linux and macOS. Native Windows Upgrading from an older install? If you set RTK up before v0.37.2 you may still have the legacy rtk-rewrite.sh shell hook (which does need a Unix shell). Re-run rtk init -g to migrate to the native binary hook. Prerequisites: some filters shell out to ripgrep (rg). Install it and keep it on your PATH (e.g. winget install BurntSushi.ripgrep.MSVC) to avoid Binary 'rg' not found on PATH warnings. Important: Do not double-click rtk.exe — it is a CLI tool that prints usage and exits immediately. Always run it from a terminal (Command Prompt, PowerShell, or Windows Terminal). WSL WSL also works and behaves exactly like Linux: | Feature | Native Windows | WSL | |---------|----------------|-----| | Filters (cargo, git, etc.) | Full | Full | | Auto-rewrite hook | Yes (native binary) | Yes | | rtk init -g | Hook mode | Hook mode | | rtk gain / analytics | Full | Full | Supported AI Tools RTK supports 16 AI coding tools. Each integration rewrites shell commands to rtk equivalents, reducing the bash output the agent reads where the agent supports command interception. | Tool | Install | Method | |------|---------|--------| | Claude Code | rtk init -g | PreToolUse hook (native binary) | | GitHub Copilot (VS Code) | rtk init -g --copilot | PreToolUse hook — transparent rewrite | | GitHub Copilot CLI | rtk init -g --copilot | PreToolUse deny-with-suggestion (CLI limitation) | | Cursor | rtk init -g --agent cursor | preToolUse hook (hooks.json) | | Gemini CLI | rtk init -g --gemini | BeforeTool hook | | Codex | rtk init -g --codex | AGENTS.md + RTK.md instructions | | Windsurf | rtk init -g --agent windsurf | .windsurfrules (project-scoped) | | Cline / Roo Code | rtk init --agent cline | .clinerules (project-scoped) | | OpenCode | rtk init -g --opencode | Plugin TS (tool.execute.before) | | OpenClaw | openclaw plugins install ./openclaw | Plugin TS (before_tool_call) | | Pi | rtk init -g --agent pi (global) | TypeScript extension (tool_call) | | Hermes | rtk init --agent hermes | Python plugin adapter (terminal command mutation via rtk rewrite) | | Mistral Vibe | rtk init -g --agent vibe | pre_tool hook (hooks.toml) | | Kilo Code | rtk init --agent kilocode | .kilocode/rules/rtk-rules.md (project-scoped) | | Google Antigravity | rtk init --agent antigravity | .agents/rules/antigravity-rtk-rules.md (project-scoped) | | Kimi AI | rtk init --agent kimi | AGENTS.md (project-scoped) | | Factory Droid | rtk init -g --agent droid (or per-project) | PreToolUse hook in ~/.factory/hooks.json (matcher Execute) | For per-agent setup details, override controls, and graceful degradation, see the Supported Agents guide. The Hermes plugin source and tests live in hooks/hermes/; installed Hermes runtime files still live under ~/.hermes/plugins/rtk-rewrite/. Configuration ~/.config/rtk/config.toml (macOS: ~/Library/Application Support/rtk/config.toml): When a command fails, RTK saves the full unfiltered output so the LLM can read it without re-executing: For the full config reference (all sections, env vars, per-project filters), see the Configuration guide. Uninstall Documentation - rtk-ai.app/guide — full user guide (installation, supported agents, what gets optimized, analytics, configuration, troubleshooting) - INSTALL.md — detailed installation reference - ARCHITECTURE.md — system design and technical decisions - CONTRIBUTING.md — contribution guide - SECURITY.md — security policy Privacy & Telemetry RTK can collect anonymous, aggregate usage metrics once per day. Telemetry is disabled by default and requires explicit opt-in consent (GDPR Art. 6, 7) during rtk init or via rtk telemetry enable. This data helps us build a better product: identifying which commands need filters, which filters need improvement, and how much value RTK delivers. For the full list of fields, data handling, and contributor guidelines, see docs/TELEMETRY.md. What is collected and why: | Category | Data | Why | |----------|------|-----| | Identity | Salted device hash (SHA-256, not reversible) | Count unique installations without tracking individuals | | Environment | RTK version, OS, architecture, install method | Know which platforms to support and test | | Usage volume | Command count (24h), total commands, estimated tokens saved (24h/30d/total) | Measure adoption and value delivered | | Quality | Top 5 passthrough commands (0% reduction), parse failure count, commands with <30% reduction | Identify missing filters and weak ones to improve | | Ecosystem | Command category distribution (e.g. git 45%, cargo 20%, js 15%) | Prioritize filter development for popular ecosystems | | Retention | Days since first use, active days in last 30 | Understand engagement and detect churn | | Adoption | AI agent hook type (claude/gemini/codex), custom TOML filter count | Track integration coverage and DSL adoption | | Configuration | Whether config.toml exists, number of excluded commands, project count | Understand user maturity and customization patterns | | Features | Usage counts for meta-commands (gain, discover, proxy, verify) | Know which RTK features are valued vs unused | | Economics | Estimated USD value, derived from the estimated tokens saved and a fixed internal constant | Quantify the value RTK provides to users | All data is aggregate counts or anonymized command names (first 3 words, no arguments). Top commands report only tool names (e.g. \"git\", \"cargo\"), never full command lines. What is NOT collected: source code, file paths, command arguments, secrets, environment variables, personal data, or repository contents. Manage telemetry: Override via environment: Star History [!NOTE] > Today: Kimi K3 is here. We have reimplemented the provider-recommended > Kimi Code harness in Rust, giving you > maximum K3 performance with a Codex-like interface. > Kimi Docs → [!NOTE] > This is the new Rust version of Open Interpreter, based on Codex. Looking for the original Python project? It lives on as a community-maintained fork at endolith/open-interpreter. License Apache-2.0", "metadata": {"source": "github_readme", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": false, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "Intent to Ship: JPEG XL", "text": "It isn’t often that new image formats land in browsers. In the early 2000s we had JPEG, GIF, and PNG. The 2010s gave us WebP, which was a modest step up from JPEG. But the 2020s have given us two new image formats that are a big step up from previous formats: AVIF and JPEG XL. We shipped AVIF back in 2021, and today we posted our intent to ship JPEG XL. Chrome are also intending to ship, and given there’s already a partial implementation in Safari, the format will be supported across browsers before the end of the year. Shipping JPEG XL securely We added experimental support for JPEG XL behind a flag back in 2021. But, at 100,000 lines of multithreaded C++, we were concerned about the attack surface this added to Firefox. So, we laid down a challenge to the JPEG XL team at Google Research: Build a safe, performant, compact, and compatible JPEG XL decoder in Rust, and we’ll ship it. That challenge was met; Google Research built jxl-rs, and it’s the core of our JPEG XL support in Firefox. We also pushed for high quality integration tests as part of an Interop 2026 investigation area, and they’re coming along nicely. Progressive rendering Although Safari shipped JPEG XL in 2023, their implementation lacked some key features of JPEG XL – our favourite is progressive rendering, which is something we pushed for in the Rust implementation. Progressive rendering means the image can render as it’s downloading. Although the full image is 135 kB, with only a few kB downloaded the user can determine the subject of the image. Try the above demo image in a browser that supports JPEG XL & progressive rendering, like Firefox Nightly – move the slider to see how the image displays with just a portion downloaded. JPEG XL vs AVIF Browsers will now have two modern image formats for developers to choose from. Which you choose depends on your use-case. - JPEG XL: Excels at lossless imagery, progressive rendering, and further compressing JPEGs without quality loss. - AVIF: Excels at web-quality photographic images, and images that have a mix of sharp edges and flat surfaces. For example: The image above is a 116 kB AVIF with a quality score (SSIMULACRA 2) of 62.8, meaning medium-high quality. To get the same quality, the JPEG XL image would be 134 kB. At a SSIMULACRA 2 score of 80 (very high quality), the AVIF is 227 kB, and the JPEG XL is 264 kB. But at lossless, the AVIF is 1.76 MB, and the JPEG XL is 1.45 MB. A lossless WebP is 1.55 MB. Another example is a screenshot of the Interop 2025 scores: At a SSIMULACRA 2 score of 78 (very high quality), the AVIF is 11.6 kB, and the JPEG XL is 23.8 kB. But at lossless, the AVIF is 164 kB, and the JPEG XL is 92 kB. A lossless WebP is 96 kB. Although AVIF tends to produce smaller files at web-quality than JPEG XL, AVIF only has basic progressive rendering support. So, for very large images, it may be worth taking the filesize hit with JPEG XL. The key is to test with a representative set of images for your site, at a quality that works best for your users, and remember to optimise for high density.", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "PACT: Anonymous Credentials for the Web", "text": "This is the technical companion to our update on Distilled, “Keeping the web open and private in the bot era.” Here we take a deeper look at the problem space, the design we’re proposing, and the problems still left to solve. Bots (and privacy-preserving browsers) not welcome Browse a news site in a private window. Shop at a major retailer with a VPN. Visit a video streaming platform with anti-fingerprinting defenses tuned up. You’ll see the same responses: registration walls, block pages, and endless CAPTCHAs. The message is clear: if we think you might be a bot, you’re not welcome. Websites have valid reasons for wanting to block bots. Bots enable volumetric abuse, abuse that wouldn’t otherwise be feasible if they had to be carried out by humans. For example: SEO comment spam, credential stuffing and DDoSing. Consequently many sites employ dedicated anti-abuse tooling which aims to keep the bots out whilst minimizing friction for human visitors. Unfortunately, that tooling is increasingly failing at both tasks. Browser privacy protections are dismantling the passive signals that anti-abuse systems depended on to identify and distinguish visitors. Meanwhile advances in generative AI have rendered CAPTCHAs ineffective: bots now solve them faster and more reliably than humans. Many sites are switching to more invasive mechanisms and now ask visitors to disclose identifying information, e.g. an email address, a federated login or disabling their VPN. This means greater friction for users, since providing these details on a first visit takes time. It also compromises their privacy, since these details enable the same kinds of cross-site tracking that browser privacy protections were intended to mitigate. This leaves users with a dilemma. The more effectively they protect their privacy, the harder it is for websites to distinguish them from bots and the worse the treatment they receive. Website operators are also suffering. The additional friction they inflict upon well-behaved visitors harms their site, but many are willing to pay the costs if it mitigates volumetric abuse. Browser-based AI agents make this tension more acute. Sites may want to allow agents which are acting on behalf of individual users while blocking agents engaged in volumetric abuse. However, with no effective mechanisms to distinguish the two, websites are opting to block both. That hurts users, who should be free to choose the user agent they use to access the web; it hurts new browsers and agents, which struggle to interoperate; and it hurts sites, which lose legitimate visitors. The consequence is that the web gets worse for everyone. Users get more friction or less privacy or both. Website operators see more volumetric abuse and the friction they add drives away users who would otherwise want to consume their content or services. New user agents struggle to access the same content as conventional browsers. The Costs of Convenient Solutions Some large ecosystem players have put forward solutions that leverage their control of the dominant operating systems and their deep integration with consumer hardware. These rely on device attestation: identifiers and privileged code baked into devices at the hardware level, which let manufacturers prove what software is running on a user’s device. Exposing this functionality to the web means attesting to sites that the user is running approved software with trusted hardware and therefore isn’t a bot. There have been two substantive proposals. Google’s Web Environment Integrity, abandoned in 2023, was the blunt version. It attested to the user agent itself, as well as the operating system and device in use. Users would have lost control in two ways: once to the attester, which would decide which operating systems and devices could be blessed, and again to the website, which would decide which software to accept. If sites had adopted allow-lists of approved user agents, building a new browser would have become virtually impossible, and sites could have withdrawn access from any user agent they chose. Apple’s Private Access Tokens, deployed across their ecosystem in 2022, have more subtle issues. Built on the Privacy Pass protocol standardized at the IETF, they get a lot right: a user receives a renewed, limited batch of one-time tokens that can be presented to websites without linking their visits together. This provides privacy for users and has shown rate limits to be an effective tool for sites – both points we’ll return to later in this post. However, Private Access Tokens rely on device attestation, requiring that the hardware manufacturer be in overall control of the user’s device. Presenting a PAT tells a website you are locked into Apple’s rules for what counts as acceptable software. Due to PAT’s technical design[1], there’s no way to open the system to other sources of scarcity without compromising the system’s privacy properties, meaning that if more widely deployed, access to the web would become tied to having bought expensive hardware from a small, hard to change set of vendors. Both approaches are ultimately hostile to users and to the openness of the web. Both are premised on parts of a user’s device that sit within the manufacturer’s control and beyond the user’s own. Were they widely deployed, the web would become just another walled garden with centralized gatekeepers controlling acceptable hardware, operating systems and software. As convenient as these solutions are for the players who already dominate the ecosystem, we think there’s a better path. A Better Path Forward Bots’ harms arise from their ability to operate beyond human scale. For sites to prevent volumetric abuse they don’t actually need to know the user’s identity or receive cryptographic proof that they’re running approved software. If sites knew their visitors were restricted to a rate limit set by a site, that would be enough. Rate limits only make sense if they’re tied to something scarce; something an attacker can’t cheaply replicate to evade the limit. Without anchoring to a scarce resource, like the trusted hardware used in Private Access Tokens, attackers can generate as many fresh identities as they need to bypass the rate limit. However, hardware is just one option for scarcity. Anything a user already has that an attacker can’t trivially spin up at scale will work: email addresses and phone numbers are naturally scarce. A paid subscription costs an attacker the same as a real user. Even maintaining an account on a free service requires some non-trivial work. What if we could use these scarce signals across the web? We could build an open ecosystem with many parties offering scarcity signals, each site choosing which to accept. By opening up who can provide a signal, and letting sites choose which to accept, we can avoid transferring control to device manufacturers and the resulting harms. As a concrete example of who might be well positioned to provide such a signal, we can consider VPN providers acting as a subscription service. Sites routinely block VPN users indiscriminately, whether through a deliberate policy choice or through an indirect consequence of rate limiting visitors per IP address. But a VPN subscription is a perfect source of scarcity. If the VPN provider could vouch for its users so that sites could rate limit each user individually – then users would be able to browse the web with less friction and without giving up their VPN usage. The catch is that building a system that can enable this on the open web whilst maintaining user’s privacy is genuinely difficult. It requires that we take information from one site — that this user holds some scarce thing — and expose it to other sites so that they can use that as the basis for their rate limiting. Letting one site verify a signal from another is the sort of information flow that privacy-preserving browsers have spent the last decade locking down to prevent cross-site tracking. Our goal would be that no more than the minimum information gets through: a single bit communicating whether the user is below the rate limit set by the site. Leaking anything more – like the source of the scarcity that the rate limit is anchored to – would be unacceptable. Enabling a new cross-site information flow might feel like compromising privacy to gain better access, but reality is more nuanced. If a new system moves sites away from demanding that visitors be identifiable (whether through fingerprinting or login forms), it can be a win for both privacy and access. The Foundations The good news is that the cryptographic foundations for a privacy preserving approach already exist. The Privacy Pass protocol, originally developed in 2018 to reduce the friction of Cloudflare CAPTCHAs for Tor users, introduced the core primitive: a token that is unlinkable between issuance and redemption. You prove something to an issuer (e.g. by solving a CAPTCHA), receive some tokens, and later present a token to a website. The website can verify the token is legitimate, but can’t link it to the user it was issued to. Figure 1: In Privacy Pass, a CAPTCHA provider can issue tokens to a client which can then be used to bypass challenges for future site visits. Even if the CAPTCHA provider and sites collude, they can’t use the tokens to identify the user or their browsing history. Privacy Pass has gone on to be successfully deployed in systems where the issuer and verifier have a prior trust relationship: Apple uses it to authenticate users of Private Cloud Compute and Private Relay without linking their activity to their identity, Chrome uses it for two-hop IP protection, and Kagi uses it to provide private search. These deployments work in part because a small number of parties have agreed in advance on who issues tokens and who accepts them. Applying this approach to an open system where any site can act as an issuer brings real challenges. Firstly, even though tokens are unlinkable, knowing a user has access to a specific issuer is a privacy leak on its own, because you can infer that the user meets the relevant issuance criteria. If one site can learn that you have a token from another site, that reveals that you have been to that site, which can be a major privacy problem. This compounds if sites can learn the set of issuers you have visited, since it becomes a fingerprint which can be used to identify you. Generic techniques exist for proving a statement in zero knowledge: we can prove that a client has a token from a set of acceptable issuers without revealing which specific issuer it is. We’ll call this issuer blinding. The generic approach is often slow, but bespoke approaches tailored to the underlying cryptography can improve this considerably. Another challenge is how sites using rate limits decide who to trust to issue tokens. If an issuer misbehaves then the site’s rate limits become ineffective, enabling volumetric abuse. However, if we need to prevent the site from learning which issuers a user has access to, the site is only going to know that one of its trusted issuers was used, not which one. This makes mistakes or misbehaviour by an issuer difficult to detect, and makes it hard for sites to evaluate new issuers. Solving this challenge is essential for openness. Without adequate information, sites are likely to lean towards conservative issuer selection. That could lead to less choice between Anchors, which in turn could lead to a new form of gatekeeper being created. To solve this, sites at least need a way to calculate an aggregate score for each issuer they use. This should roughly correspond to how much of the traffic it considers abusive to have come from users using that particular issuer. Mozilla has long invested in systems like Prio which use multiparty computation (MPC) to protect user privacy whilst enabling aggregate measurements of system behaviour. Privacy Pass also struggles to handle dynamic adjustments to rate…", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.422, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.422}}
{"format": "sequential_text", "title": "Firefox 151 enables web serial communication with hardware", "text": "Support for Web Serial in Firefox 151 for Desktop Firefox can now connect directly to microcontrollers, development boards, 3D printers, power meters, and other serial-connected hardware from the web. Starting in Firefox 151 for Desktop, support for the Web Serial API allows web applications to communicate with compatible devices without requiring native software. Web Serial compatible devices are popular among hobbyists, hardware hackers, educators, makers, and developers with use cases ranging from home automation to hardware prototyping and 3D printing. Web Serial support makes Firefox more useful for these kinds of projects. One of the organizations that has demonstrated the value of Web Serial is Adafruit, a leader in open-source hardware and STEM education. They’ve made it quick and easy to install CircuitPython on their devices by delivering firmware over Web Serial. Then it’s straightforward to run Python programs on the device. Name your file code.py and, for most devices, the code can be installed by dragging-and-dropping the file onto the USB device. Your Python programs can interoperate with a web page over Web Serial using simple text-based I/O. OPEN INSTALLER method on the CircuitPython site.Here’s an example using an Adafruit ESP32-S2 based board where messages sent from web code can be directly displayed on the device over Web Serial. code.py file.We’ve collaborated with Adafruit to test Firefox’s implementation against real hardware workflows commonly used by this community. The result: Firefox is a more practical browser for programming and interacting with hardware directly using web technology. As an example of how you can combine Web Serial with electronics, Mozilla engineer Alex Franchuk created an amazingly fun and functional device that melds electronics and web editing. Check out the Page Playground. The list of serial compatible devices includes Espressif ESP-based boards such as the popular ESP32 chips, Raspberry Pi Picos, 3D printers, LEGO devices, and many more. There are many tools for running your own code on these small affordable microcontroller boards, and with Web Serial it’s easier than ever to connect them to a computer and interact through a web-based user interface. What is Web Serial? Web Serial is a web API that allows a website to read and write to serial devices using JavaScript. See the MDN documentation for the details. While modern computers don’t typically include serial ports, serial devices connected to a USB port or paired via Bluetooth can advertise themselves as serial-capable devices so they appear as serial ports in the operating system. The Web Serial API lets developers use the web platform to communicate with these devices. For example, websites can control devices or deliver firmware without requiring native applications or installers. Mozilla’s own Florian Quèze, who has experimented with many projects to measure power consumption, demonstrated how Web Serial could be used to read power data from an off-the-shelf USB power meter and display it in Firefox. Florian’s code can also export the data into the Firefox Profiler, making it easy to visualize and share power data. Here’s the page and GitHub repo. The screenshots below show the page in action and the data in the Firefox Profiler after recording the power usage of a light with three brightness modes. Home Assistant is another example. It’s a popular (and growing) open source project for home automation. The ESPHome project offers Home Assistant-compatible firmware for affordable ESP32 and similar devices which can be installed and configured over Web Serial in just a few clicks. Security and Privacy There are clear security and privacy concerns with allowing the web platform to read and write to hardware devices. Most importantly, with Web Serial, websites do not have visibility or access to serial ports until the user explicitly allows it. Ports are allowed on a per-site and per-port basis. The Web Serial API requires websites to call navigator.serial.requestPort() , which lets the user choose which port to allow access to, or disallow all access entirely. This means websites do not receive a list of connected devices and there is no useful fingerprinting information outside of the port the user selects. To help users understand when and why a site requests access to a serial port, Firefox uses add-on gating which we introduced with our Web MIDI API implementation. Compared to other web permission prompts, this gives the user a more detailed explanation of what they’re allowing. The add-on gating prompts appear before the port selection prompt the first time a site requests port access. For organizations using Firefox Enterprise Policies, Web Serial is disabled by default. Administrators can explicitly allow or disallow Web Serial functionality across their organization using the DefaultSerialGuardSetting policy setting. Standardization While Web Serial still resides in the Web Incubator Community Group (WICG), we’re optimistic there’s a path to standardization given its scope and long-running incubation. We are pursuing standardizing the Web Serial API in the WHATWG in a new Workstream proposal and are excited to work with ecosystem partners and standards bodies to help shape access to peripherals on the web. Feedback If you already have a Web Serial workflow with a device you can test on, give Firefox a try. We’d love to hear what you’re building and which workflows matter most to you. Mozilla Connect is a great place to share projects, ask questions, and give feedback. For technical issues, browse to support.mozilla.org or file a bug here. About Haik Aftandilian More articles by Haik Aftandilian…", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.373, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.373}}
{"format": "sequential_text", "title": "Behind the Scenes Hardening Firefox with Claude Mythos…", "text": "Two weeks ago we announced that we had identified and fixed an unprecedented number of latent security bugs in Firefox with the help of Claude Mythos Preview and other AI models. In this post, we’ll go into more detail about how we approached this work, what we found, and advice for other projects on making good use of emerging capabilities to harden themselves against attack. Suddenly, the bugs are very good Just a few months ago, AI-generated security bug reports to open source projects were mostly known for being unwanted slop. Dealing with reports that look plausibly correct but are wrong imposes an asymmetric cost on project maintainers: it’s cheap and easy to prompt an LLM to find a “problem” in code, but slow and expensive to respond to it. It is difficult to overstate how much this dynamic changed for us over a few short months. This was due to a combination of two main factors. First, the models got a lot more capable. Second, we dramatically improved our techniques for harnessing these models — steering them, scaling them, and stacking them to generate large amounts of signal and filter out the noise. Ordinarily we keep detailed bug reports private for several months after shipping fixes and issuing security advisories, largely as a precaution to protect any users who, for whatever reason, were slow to update to the latest version of Firefox. Given the extraordinary level of interest in this topic and the urgency of action needed throughout the software ecosystem, we’ve made the calculated decision to unhide a small sample of the reports behind the fixes we recently shipped. We’ve attempted to draw them from a range of browser subsystems, but the selection process was still somewhat arbitrary. Nevertheless, we hope that the depth and diversity of these reports lends credence to our assessment of the capabilities and our calls for defenders to begin applying these techniques: Note that a number of these bugs are sandbox escapes, which would need to be combined with other exploits to achieve a full-chain Firefox compromise. These reports presume that the sandboxed process that renders site content has already been compromised with some separate bug, and is now running attacker-controlled machine code attempting to escalate control into the privileged parent process. When crafting a sandbox escape, the model is permitted to patch the Firefox source code, so long as the modified code is restricted to run only in the sandboxed process[1]. Such bugs are notoriously difficult to find with fuzzing, and while we’ve had some success developing new techniques to close this gap, AI analysis provides much more comprehensive coverage of this critical surface. Just as interesting as what the models found is what they didn’t find — not because they didn’t try, but because they were unable to circumvent Firefox’s layered defenses. For example, in recent years we received several clever reports from security researchers that managed to escape the process sandbox by triggering prototype pollution in the privileged parent process. Rather than fixing these problems one-by-one, we made an architectural change to freeze these prototypes by default. While auditing logs from the harness, we saw many attempts to pursue this line of escape that were thwarted by this design. Observing such direct payoff from previous hardening work was even more rewarding than finding and fixing more bugs. Harnessing Models to Build a Hardening Pipeline We’ve experimented internally with LLM code audits over the past few years, with early attempts using models like GPT 4 or Sonnet 3.5 to statically analyze high risk code for vulnerabilities. These experiments showed some promise, but the high rate of false positives made them impractical to scale. The introduction of agentic harnesses that can reliably detect security issues has completely changed this. These can find real bugs and dismiss unreproducible speculation. The key feature of such a harness is that, given the right interfaces and instructions, it can create and run reproducible test cases to dynamically test hypotheses about bugs in code. After fixing the initial set of issues that Anthropic sent to us in February, we built our own harness atop our existing fuzzing infrastructure. We began with small-scale experiments prompting the harness to look for sandbox escapes with Claude Opus 4.6. Even with this model, we identified an impressive amount of previously-unknown vulnerabilities which required complex reasoning over multiprocess browser engine code. At first, we supervised the process in the terminal to observe the process in real-time and tune the prompts and logic. Once this was working well, we parallelized the jobs across multiple ephemeral VMs, each tasked to hunt for bugs within a specific target file and write its findings back to a bucket. A discovery subsystem is necessary but not sufficient. In order to scale the effort, we needed to integrate it with our full security bug lifecycle: determining what to look for, where to look, and how to handle what it produces. This last part includes deduplicating against known issues, tracking bugs, triaging them, and getting fixes shipped. While the model is the core primitive powering the harness, this full pipeline is necessary to make it useful at scale. While harnesses may be reusable across projects, this pipeline is inherently project-specific, reflecting each codebase’s semantics, tooling, and processes. Standing this up required significant iteration, with a tight feedback loop alongside the Firefox engineers who were fielding the incoming bugs. Upgrading the Models Once the end-to-end pipeline is in place, it’s trivial to swap in different models when they become available. Building this pipeline early helped us find a number of serious bugs using publicly-available models, and it also helped us hit the ground running when we had the opportunity to evaluate Claude Mythos Preview. In our experience, model upgrades increase the effectiveness of the entire pipeline: the system gets simultaneously better at finding potential bugs, creating proof-of-concept test cases to demonstrate them, and articulating their pathology and impact. In addition to fixing the 271 bugs identified by Claude Mythos Preview in the 150 release, we’ve shipped more of these fixes in 149.0.2, 150.0.1, and 150.0.2. We also continue to find bugs with other means internally, and, similar to other projects, we’ve seen a significant uptick in external reports in the last few months. Ultimately, every bug requires care and attention to properly fix. Staying on top of this unprecedented volume has led to a lot of work and long days over the last few months, and we’re extremely proud of how the team has stepped up to meet this challenge. Over 100 people contributed code to this effort to ship the most secure Firefox yet. In addition to writing and reviewing patches, others have been building and scaling this pipeline, triaging, testing the fixes, and managing the release process for each bug. Takeaways Anyone building software can start using a harness with a modern model to find bugs and harden their code today. We recommend getting started now. You will find bugs, and you will set yourself up to take advantage of new models as soon as they become available. You can start with very simple prompting, then observe and iterate. Our initial prompts were not dissimilar from those described here. Through iteration we’ve built out a lot of orchestration and tooling to optimize and scale the pipeline, but the essence of the inner loop remains the same: there is a bug in this part of the code, please find it and build a testcase. We haven’t bottomed on all the latent bugs in Firefox, but are quite pleased with the trajectory. Today, our scanning is largely focused on specific areas of the code (files, functions) where we instruct the system to look, based on a mix of human judgement and automated signals. In the near future, we intend to integrate this analysis into our continuous integration system to scan patches as they land in the tree. Models are quite flexible with the form of context provided, and we expect patch-based scanning to work as well or even better than file-based scanning. The current moment is a perilous one, but also full of opportunity. Let’s work together to secure the internet. FAQ The announcement said “271 bugs”, but I count something different. What’s going on? On the advisories web page we group all internally-reported bugs as “rollup” CVEs with multiple bugs underneath them. The web page is built from yaml in the foundation-security-advisories repo, the canonical location for our CVE assignments. While some browsers do not create CVE identifiers for internally-discovered issues at all, we provide this information in order to be as transparent as possible. In Firefox 150, there were three internal rollups: CVE-2026-6784 (154 bugs), CVE-2026-6785 (55 bugs), and CVE-2026-6786 (107 bugs). Astute readers will notice the number of bugs in those internal rollups adds up to 316, which is more than the 271 we announced finding with Claude Mythos Preview. That’s because our security team hunts for new bugs every day by attacking Firefox with a combination of (a) fuzzing systems (b) manual inspection and (c) this new agentic pipeline across a variety of models. We fixed a total of 423 security bugs in releases in April. In addition to the 271 bugs announced two weeks ago, there were 41 externally reported bugs, with the remaining 111 discovered internally and split roughly in third between: - Bugs found using this pipeline with Claude Mythos Preview but fixed in releases other than Firefox 150 - Bugs found using this pipeline with other models - Bugs found with other techniques like fuzzing Note that we also directly credited 3 CVEs to Anthropic separate from this latest effort (CVE-2026-6746, CVE-2026-6757, CVE-2026-6758). These were fixes for bugs sent to us by the outstanding Anthropic Frontier Red team a couple months ago and we assigned unique CVEs for each as per our normal process. What do security ratings mean? As additional context, we apply security severity ratings from critical to low to indicate the urgency of a bug: - sec-critical and sec-high are assigned to vulnerabilities that can be triggered with normal user behavior, like browsing to a web page. We make no technical difference between these, but sec-critical bugs are reserved for issues that are publicly disclosed or known to be exploited in the wild. - sec-moderate is assigned to vulnerabilities that would otherwise be rated sec-high but require unusual and complex steps from the victim. - sec-low is assigned to bugs that are annoying but far from causing user harm (e.g, a safe crash). Of the 271 bugs we announced for Firefox 150: 180 were sec-high, 80 were sec-moderate, and 11 were sec-low. While we care most about critical/high bugs, it’s normal for us to prioritize moderate and low security bugs in order to fix correctness issues and as a defense-in-depth mechanism. Is a sec-high or sec-critical bug the same as a practical exploit? Not necessarily. In most cases, a single critical/high bug is not actually enough to compromise Firefox. This is because Firefox has a defense-in-depth architecture, so for example exploiting a JIT bug only achieves remote code execution in a sandboxed and site-specific process. Real-world attackers generally need to chain multiple exploits together to escalate privileges through one or more layers of sandboxing along with OS-level mitigations like ASLR. We also generally don’t build exploits to see whether a bug could be used by an attacker in the real world. We classify sec-high based on predictable crash symptoms such as use-after-free or out-of-bounds memory issues being reported by AddressSanitizer, and our threat model assumes that any of them could be exploitable with sufficient effort. This reduces the…", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.041, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.041}}
{"format": "sequential_text", "title": "Trustworthy JavaScript for the Open Web", "text": "The open web is a critical platform for applications that handle highly sensitive data, from private communications to financial transactions and medical records. Traditionally, servers are trusted to deliver the appropriate code and resources for their web applications to browsers, who then provide a secure and isolated environment for their execution. In some circumstances, this trust model falls short. Consider a browser-based messaging application, like Signal or WhatsApp, which uses end-to-end encryption. The browser depends on the server to provide a trustworthy javascript implementation of the app; which ensures the user’s messages and cryptographic keys are suitably protected. A malicious or compromised server could selectively serve modified code to some users, undermining their security with little risk of detection. This challenges the basic premise of end-to-end encryption: that a misbehaving server should not be able to compromise user security. Towards Verifiable Security on the Web For web applications to be trustworthy in the presence of malicious servers, two properties are essential: - Integrity: The code executed by the user matches what the developer committed to in a manifest. - Transparency: These manifests are publicly logged and can be independently audited. Web Application Integrity, Consistency and Transparency (WAICT) brings these properties to the web platform. WAICT allows websites to cryptographically bind their client-side code to a manifest and commit that manifest to a publicly auditable log. Sites which need this stronger trust model can then opt in to WAICT enforcement. If an opted-in site delivers code that has not been publicly logged, the browser rejects it and attacks that were previously invisible become observable and attributable. This ensures that the code delivered to user’s machines is consistent with the publicly available code which security researchers can inspect. Bringing Integrity and Transparency to the Open Web We are collaborating with partners across the ecosystem – including Cloudflare, the Freedom of the Press Foundation and Meta – to ensure the deployment model is practical, secure, and as simple as possible. You can learn more about WAICT in our joint talk at Real World Cryptography 2026. An early prototype of WAICT is available behind a pref in Firefox Nightly to help validate the approach in real-world scenarios. You can test drive the prototype on – including an end-to-end encrypted video calling app secured by WAICT. The implementation is a work in progress, not a finished solution, but it provides a concrete foundation for iteration and standardization. We’re developing the specifications in the open and welcome early feedback. WAICT marks an important step toward making strong, verifiable application security a first-class property of the open web. With special thanks to Anna Weine, Benjamin Beurdouche, Christoph Kerschbaumer, Dennis Jackson, Frederik Braun, and Tom Schuster. About Firefox Security Team The Security Engineering Team provides core security and privacy guarantees which allows individuals to safely browse the web using Firefox", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "Firefox Developer Edition and Beta: Try out Mozilla’s…", "text": "In January, we introduced our Nightly package for RPM-based Linux distributions. Today, we are thrilled to announce it is now available for Firefox Beta! Firefox Beta is great for testing your sites in a version of Firefox that will reach regular users in the coming weeks. If you find any issues, please file them on Bugzilla. Switching to Mozilla’s RPM repository allows Firefox Beta to be installed and updated like any other application, using your favorite package manager. It also provides a number of improvements: - Better performance thanks to our advanced compiler-based optimizations, - Updates as fast as possible because the .rpm management is integrated into Firefox’s release process, - Hardened binaries with all security flags enabled during compilation, - No need to create your own .desktop file. If you have Mozilla’s RPM repository already set up, you can simply install Firefox Beta with your package manager. Otherwise, follow the setup steps below. If you are on Fedora (41+), or any other distribution using dnf5 as the package manager sudo dnf config-manager addrepo --id=mozilla --set=baseurl= --set=gpgkey= --set=gpgcheck=1 --set=repo_gpgcheck=0 sudo dnf makecache --refresh sudo dnf install firefox-beta Note: repo_gpgcheck=0 deactivate the signature of metadata with GPG. However, this is safeguarded instead by HTTPS and package signatures (gpgcheck=1 ). If you are on openSUSE or any other distribution using zypper as the package manager sudo rpm --import sudo zypper ar --gpgcheck-allow-unsigned-repo mozilla sudo zypper refresh sudo zypper install firefox-beta For other RPM based distributions (RHEL, CentOS, Rocky Linux, older Fedora versions) sudo tee /etc/yum.repos.d/mozilla.repo > /dev/null << EOF [mozilla] name=Mozilla Packages baseurl= enabled=1 gpgcheck=1 repo_gpgcheck=0 gpgkey= EOF For dnf users sudo dnf makecache --refresh sudo dnf install firefox-beta For zypper users sudo zypper refresh sudo zypper install firefox-beta The firefox-beta package will not conflict with your distribution’s Firefox package if you have it installed, you can have both at the same time! Adding language packs If your distribution language is set to a supported language, language packs for it should automatically be installed. You can also install them manually with the following command (replace fr with the language code of your choice): sudo dnf install firefox-beta-l10n-fr You can list the available languages with the following command: dnf search firefox-beta-l10n Don’t hesitate to report any problem you encounter to help us make your experience better.", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.46, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.46}}
{"format": "sequential_text", "title": "Why is WebAssembly a second-class language on the…", "text": "This post is an expanded version of a presentation I gave at the 2025 WebAssembly CG meeting in Munich. WebAssembly has come a long way since its first release in 2017. The first version of WebAssembly was already a great fit for low-level languages like C and C++, and immediately enabled many new kinds of applications to efficiently target the web. Since then, the WebAssembly CG has dramatically expanded the core capabilities of the language, adding shared memories, SIMD, exception handling, tail calls, 64-bit memories, and GC support, alongside many smaller improvements such as bulk memory instructions, multiple returns, and reference values. These additions have allowed many more languages to efficiently target WebAssembly. There’s still more important work to do, like stack switching and improved threading, but WebAssembly has narrowed the gap with native in many ways. Yet, it still feels like something is missing that’s holding WebAssembly back from wider adoption on the Web. There are multiple reasons for this, but the core issue is that WebAssembly is a second-class language on the web. For all of the new language features, WebAssembly is still not integrated with the web platform as tightly as it should be. This leads to a poor developer experience, which pushes developers to only use WebAssembly when they absolutely need it. Oftentimes JavaScript is simpler and “good enough”. This means its users tend to be large companies with enough resources to justify the investment, which then limits the benefits of WebAssembly to only a small subset of the larger Web community. Solving this issue is hard, and the CG has been focused on extending the WebAssembly language. Now that the language has matured significantly, it’s time to take a closer look at this. We’ll go deep into the problem, before talking about how WebAssembly Components could improve things. What makes WebAssembly second-class? At a very high level, the scripting part of the web platform is layered like this: WebAssembly can directly interact with JavaScript, which can directly interact with the web platform. WebAssembly can access the web platform, but only by using the special capabilities of JavaScript. JavaScript is a first-class language on the web, and WebAssembly is not. This wasn’t an intentional or malicious design decision; JavaScript is the original scripting language of the Web and co-evolved with the platform. Nonetheless, this design significantly impacts users of WebAssembly. What are these special capabilities of JavaScript? For today’s discussion, there are two major ones: - Loading of code - Using Web APIs Loading of code WebAssembly code is unnecessarily cumbersome to load. Loading JavaScript code is as simple as just putting it in a script tag: WebAssembly is not supported in script tags today, so developers need to use the WebAssembly JS API to manually load and instantiate code. let bytecode = fetch(import.meta.resolve('./module.wasm')); let imports = { ... }; let { exports } = await WebAssembly.instantiateStreaming(bytecode, imports); The exact sequence of API calls to use is arcane, and there are multiple ways to perform this process, each of which has different tradeoffs that are not clear to most developers. This process generally just needs to be memorized or generated by a tool for you. Thankfully, there is the esm-integration proposal, which is already implemented in bundlers today and which we are actively implementing in Firefox. This proposal lets developers import WebAssembly modules from JS code using the familiar JS module system. import { run } from \"/module.wasm\"; run(); In addition, it allows a WebAssembly module to be loaded directly from a script tag using type=”module”: This streamlines the most common patterns for loading and instantiating WebAssembly modules. However, while this mitigates the initial difficulty, we quickly run into the real problem. Using Web APIs Using a Web API from JavaScript is as simple as this: console.log(\"hello, world\"); For WebAssembly, the situation is much more complicated. WebAssembly has no direct access to Web APIs and must use JavaScript to access them. The same single-line console.log program requires the following JavaScript file: // We need access to the raw memory of the Wasm code, so // create it here and provide it as an import. let memory = new WebAssembly.Memory(...); function consoleLog(messageStartIndex, messageLength) { // The string is stored in Wasm memory, but we need to // decode it into a JS string, which is what DOM APIs // require. let messageMemoryView = new UInt8Array( memory.buffer, messageStartIndex, messageLength); let messageString = new TextDecoder().decode(messageMemoryView); // Wasm can't get the console global, or do // property lookup, so we do that here. return console.log(messageString); } // Pass the wrapped Web API to the Wasm code through an // import. let imports = { \"env\": { \"memory\": memory, \"consoleLog\": consoleLog, }, }; let { instance } = await WebAssembly.instantiateStreaming(bytecode, imports); instance.exports.run(); And the following WebAssembly file: (module ;; import the memory from JS code (import \"env\" \"memory\" (memory 0)) ;; import the JS consoleLog wrapper function (import \"env\" \"consoleLog\" (func $consoleLog (param i32 i32)) ) ;; export a run function (func (export \"run\") (local i32 $messageStartIndex) (local i32 $messageLength) ;; create a string in Wasm memory, store in locals ... ;; call the consoleLog method local.get $messageStartIndex local.get $messageLength call $consoleLog ) ) Code like this is called “bindings” or “glue code” and acts as the bridge between your source language (C++, Rust, etc.) and Web APIs. This glue code is responsible for re-encoding WebAssembly data into JavaScript data and vice versa. For example, when returning a string from JavaScript to WebAssembly, the glue code may need to call a malloc function in the WebAssembly module and re-encode the string at the resulting address, after which the module is responsible for eventually calling free. This is all very tedious, formulaic, and difficult to write, so it is typical to generate this glue automatically using tools like embind or wasm-bindgen. This streamlines the authoring process, but adds complexity to the build process that native platforms typically do not require. Furthermore, this build complexity is language-specific; Rust code will require different bindings from C++ code, and so on. Of course, the glue code also has runtime costs. JavaScript objects must be allocated and garbage collected, strings must be re-encoded, structs must be deserialized. Some of this cost is inherent to any bindings system, but much of it is not. This is a pervasive cost that you pay at the boundary between JavaScript and WebAssembly, even when the calls themselves are fast. This is what most people mean when they ask “When is Wasm going to get DOM support?” It’s already possible to access any Web API with WebAssembly, but it requires JavaScript glue code. Why does this matter? From a technical perspective, the status quo works. WebAssembly runs on the web and many people have successfully shipped software with it. From the average web developer’s perspective, though, the status quo is subpar. WebAssembly is too complicated to use on the web, and you can never escape the feeling that you’re getting a second class experience. In our experience, WebAssembly is a power user feature that average developers don’t use, even if it would be a better technical choice for their project. The average developer experience for someone getting started with JavaScript is something like this: There’s a nice gradual curve where you use progressively more complicated features as the scope of your project increases. By comparison, the average developer experience for someone getting started with WebAssembly is something like this: You immediately must scale “the wall” of wrangling the many different pieces to work together. The end result is often only worth it for large projects. Why is this the case? There are several reasons, and they all directly stem from WebAssembly being a second class language on the web. 1. It’s difficult for compilers to provide first-class support for the web Any language targeting the web can’t just generate a Wasm file, but also must generate a companion JS file to load the Wasm code, implement Web API access, and handle a long tail of other issues. This work must be redone for every language that wants to support the web, and it can’t be reused for non-web platforms. Upstream compilers like Clang/LLVM don’t want to know anything about JS or the web platform, and not just for lack of effort. Generating and maintaining JS and web glue code is a specialty skill that is difficult for already stretched-thin maintainers to justify. They just want to generate a single binary, ideally in a standardized format that can also be used on platforms besides the web. 2. Standard compilers don’t produce WebAssembly that works on the web The result is that support for WebAssembly on the web is often handled by third-party unofficial toolchain distributions that users need to find and learn. A true first-class experience would start with the tool that users already know and have installed. This is, unfortunately, many developers’ first roadblock when getting started with WebAssembly. They assume that if they just have rustc installed and pass a –target=wasm flag that they’ll get something they could load in a browser. You may be able to get a WebAssembly file doing that, but it will not have any of the required platform integration. If you figure out how to load the file using the JS API, it will fail for mysterious and hard-to-debug reasons. What you really need is the unofficial toolchain distribution which implements the platform integration for you. 3. Web documentation is written for JavaScript developers The web platform has incredible documentation compared to most tech platforms. However, most of it is written for JavaScript. If you don’t know JavaScript, you’ll have a much harder time understanding how to use most Web APIs. A developer wanting to use a new Web API must first understand it from a JavaScript perspective, then translate it into the types and APIs that are available in their source language. Toolchain developers can try to manually translate the existing web documentation for their language, but that is a tedious and error prone process that doesn’t scale. 4. Calling Web APIs can still be slow If you look at all of the JS glue code for the single call to console.log above, you’ll see that there is a lot of overhead. Engines have spent a lot of time optimizing this, and more work is underway. Yet this problem still exists. It doesn’t affect every workload, but it’s something every WebAssembly user needs to be careful about. Benchmarking this is tricky, but we ran an experiment in 2020 to precisely measure the overhead that JS glue code has in a real world DOM application. We built the classic TodoMVC benchmark in the experimental Dodrio Rust framework and measured different ways of calling DOM APIs. Dodrio was perfect for this because it computed all the required DOM modifications separately from actually applying them. This allowed us to precisely measure the impact of JS glue code by swapping out the “apply DOM change list” function while keeping the rest of the benchmark exactly the same. We tested two different implementations: - “Wasm + JS glue”: A WebAssembly function which reads the change list in a loop, and then asks JS glue code to apply each change individually. This is the performance of WebAssembly today. - “Wasm only”: A WebAssembly function which reads the change list in a loop, and then uses an experimental direct binding to the DOM which skips JS glue code. This is the performance of WebAssembly if we could skip JS glue code. The duration to apply the DOM changes dropped by 45% when…", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.385, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.385}}
{"format": "sequential_text", "title": "Goodbye innerHTML, Hello setHTML: Stronger XSS Protection in…", "text": "Cross-site scripting (XSS) remains one of the most prevalent vulnerabilities on the web. The new standardized Sanitizer API provides a straightforward way for web developers to sanitize untrusted HTML before inserting it into the DOM. Firefox 148 is the first browser to ship this standardized security enhancing API, advancing a safer web for everyone. We expect other browsers to follow soon. An XSS vulnerability arises when a website inadvertently lets attackers inject arbitrary HTML or JavaScript through user-generated content. With this attack, an attacker could monitor and manipulate user interactions and continually steal user data for as long as the vulnerability remains exploitable. XSS has a long history of being notoriously difficult to prevent and has ranked among the top three web vulnerabilities (CWE-79) for nearly a decade. Firefox has been deeply involved in solutions for XSS from the beginning, starting with spearheading the Content-Security-Policy (CSP) standard in 2009. CSP allows websites to restrict which resources (scripts, styles, images, etc.) the browser can load and execute, providing a strong line of defense against XSS. Despite a steady stream of improvements and ongoing maintenance, CSP did not gain sufficient adoption to protect the long tail of the web as it requires significant architectural changes for existing web sites and continuous review by security experts. The Sanitizer API is designed to help fill that gap by providing a standardized way to turn malicious HTML into harmless HTML — in other words, to sanitize it. The setHTML( ) method integrates sanitization directly into HTML insertion, providing safety by default. Here is an example of sanitizing a simple unsafe HTML: document.body.setHTML( Hello my name is ); This sanitization will allow the HTML element while removing the embedded element and its onclick attribute, thereby eliminating the XSS attack resulting in the following safe HTML: Hello my name is Developers can opt into stronger XSS protections with minimal code changes by replacing error-prone innerHTML assignments with setHTML(). If the default configuration of setHTML( ) is too strict (or not strict enough) for a given use case, developers can provide a custom configuration that defines which HTML elements and attributes should be kept or removed. To experiment with the Sanitizer API before introducing it on a web page, we recommend exploring the Sanitizer API playground. For even stronger protections, the Sanitizer API can be combined with Trusted Types, which centralize control over HTML parsing and injection. Once setHTML( ) is adopted, sites can enable Trusted Types enforcement more easily, often without requiring complex custom policies. A strict policy can allow setHTML( ) while blocking other unsafe HTML insertion methods, helping prevent future XSS regressions. The Sanitizer API enables an easy replacement of innerHTML assignments with setHTML( ) in existing code, introducing a new safer default to protect users from XSS attacks on the web. Firefox 148 supports the Sanitizer API as well as Trusted Types, which creates a safer web experience. Adopting these standards will allow all developers to prevent XSS without the need for a dedicated security team or significant implementation changes. Image credits for the illustration above: Website, by Desi Ratna; Person, by Made by Made; Hacker by Andy Horvath. About Tom Schuster More articles by Tom Schuster… About Frederik Braun Frederik Braun manages the Firefox Application Security team. He builds security for the web and for Mozilla Firefox from Berlin. As a contributor to standards, Frederik is also improving the web platform by bringing security into the defaults with specifications like the Sanitizer API and Subresource Integrity. When not at work, Frederik likes reading a good novel or going on long bike treks across Europe. More articles by Frederik Braun… About Christoph Kerschbaumer Christoph has over two decades of experience in software engineering and computer security. His expertise includes designing secure systems with fail-safe defaults, mitigating cross-site scripting vulnerabilities, preventing machine-in-the-middle attacks, and advancing security foundations for trustworthy AI systems. He earned his Ph.D. in Computer Science from the University of California, Irvine, where his research focused on information flow tracking techniques in web browsers.", "metadata": {"source": "https://hacks.mozilla.org/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "Java's development and cross-platform strategy", "text": "Ryan sits down with Tim Lindholm, an early contributor to the Java language at Sun Microsystems, to chat about what it was like building one of the most popular programming languages ever at its inception, why it was strategically important for the Java team to create a cross-platform ABI to compete with Windows NT, and how applets were initially just an interesting demo. Watch the new documentary by Cult.Repo on YouTube to learn more about the early history of Java and the people who built it.", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "When you keep AI Lean, you keep AI…", "text": "Lean is a functional programming language and proof assistant that allows developers to write programs and verify their mathematical correctness within the exact same system. Connect with Leo on LinkedIn and check out his many badges on Stack Overflow. Congrats to Populist badge winner Peter Lawrey for winning the badge on their answer to Check two float/double values for exact equality.", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "Inside LinkedIn's cognitive memory agent for agentic personalization", "text": "Praveen explains why his team moved off GraphRAG in favor of a tree-structured memory for faster incremental updates and how they balance retrieval freshness, latency budgets, and access control at LinkedIn's scale. Connect with Praveen on LinkedIn. Congrats to Populist badge winner Luka Ganić, who answered SVG image as button in Flutter so well it outscored the accepted answer! TRANSCRIPT Ryan Donovan (00:00) Hello, everyone, and welcome to the Stack Overflow Podcast, a place to talk all things software and technology. I'm your host, Ryan Donovan, and today we are talking about a very, very large agentic memory operation there they put together at LinkedIn. And my guest for that is Praveen Badagutla, who is a principal AI He's a principal AI researcher over at LinkedIn. So welcome to the show, Praveen. Praveen Bodigutla (00:35) Thank you, very nice to meet you, Ryan. Ryan Donovan (00:37) Yeah. Glad you could be here. So before we get into the the topic today, tell us a little bit about how you got into software and technology. Praveen Bodigutla (00:47) as I said, I'm a principal AI researcher at LinkedIn and I lead a few foundation efforts, including the memory agent as well as like being the founding engineer and led some of the AI product development, both for the enterprise as well as the consumer side. the journey to where I'm right now and how I landed here is pretty nonlinear. I actually Ryan Donovan (01:08) Mm-hmm. Praveen Bodigutla (01:09) started as a platform engineer at Yahoo a long time ago after. Finishing my undergrad in like computer science and economics. Then I did like a couple of masters in financial mathematics as well as data sciences from Stanford and NYU, where I got the opportunity to work with some of the renowned professors such as like Andrew Ng, Kyun Kyoon Chou, and Jeffrey Ullman. In my past life, I was a quant developer at the Investment Bank in New York. And after that I joined Alexa, where I worked on dialogue model research. So the central theme of the career has been innovating on the side of AI and building platforms Ryan Donovan (01:51) Uhhuh. Praveen Bodigutla (01:52) so that the innovation translates into useful products for the end users. Ryan Donovan (01:58) Yeah. and I think, you know, we're we're talking about something today that that feels like a a big i innovation in a space that a lot of people are talking about, the agentic memory and context layers. now you all built a whole cognitive memory agent that that serves something. Can you give us a little little overview of what the project was? Praise. Praveen Bodigutla (02:25) Right, so let's start with like why we actually build the cognitive memory agent. Ryan Donovan (02:30) Yeah, that's a good start. Yeah. Praveen Bodigutla (02:32) So LinkedIn has developed and successfully launched this hiring agent or hiring assistance for the recruiters to manage their hiring workflows. And what we observed was through these interactions that the recruiter had with these agents, they expressed some of their hiring preferences and also they refined the role that they're hiring for. Not only do they mention like where they are hiring for and also what are the skills that they're interested in, they also give direct feedback on the candidates that were shown to them. So what we observed was there is stickiness to these preferences, which actually translate to how they define a role on similar titles and other roles that they're hiring for. So in order to provide this really true agentic experience for recruiters. We wanted to provide this personalization layer, and that is the genesis of the cognitive memory agent, which gives this concept of state for our Ryan Donovan (03:32) Mm-hmm. Praveen Bodigutla (03:33) for our agents, which the users, which in this case are recruiters who were interacting with that. And why a memory agent is because we wanted to not just fetch context, but also manage the entire life cycle of memory or the whole memory flywheel, starting from Understanding what's ingested, what's retrieved, Ryan Donovan (03:54) Mm-hmm. Praveen Bodigutla (03:55) how it is contextually relevant, and how is it even organized and updated. So the memory agent basically manages this entire flywheel and provides this deep personalization for our end users. And that was the reason why we developed the memory agent. Ryan Donovan (04:13) Yeah. And I I think it's it's interesting you mentioned state and it's not just a sort of session conversational state. It's not just a sort of preferences state. Like it's a a whole it's a three layer sort of burrito of state here. can you talk about the what those three layers are and and and why you needed three layers? Praveen Bodigutla (04:37) Right, so the three layers or like the four layers or rather the memory that we use within our memory agent are one of them is the conversation memory, which is let's say you and I are interacting right now and we are expressing our preferences in terms of like different the tasks that we are trying to achieve. So that's most recent and that's up to date, and that's the information we have. Then we have on the other end our semantic memory layer, which is the aggregated information of the user based on the interactions and preferences that they have expressed across sessions. And as you know, on LinkedIn we have different product offerings and different surfaces where the users interact with, and recruiters not only use the hiring assistant agent but also use a search platform to look for candidates. So they express those preferences there. So we want to make sure that. The experience that the users have is we know what they're looking for and we are personalizing the whole experience for them. So the the semantic layer aggregates information not just across different interactions that the user has with the agent, but also they're based on their activities that they have on related product services as well. Now, in between, we also have the episodic store, which gives this temporal querying layer where we can identify that hey what are the most recent relevant activities that this user performed. So it not only provides like the specificity of the signal and also provides provenance. Let's say we aggregate information, we can now trace it back to, what were the activities that went in that helped us to come to this conclusion that this is the preference of the end user. And the last but not least is the procedural memory layer. Every user, every recruiter if they're actually interacting with the agent, even if they're hiring for similar roles, the way they interact, the trade-offs they make and the preferences they express are very different. Some of them might Ryan Donovan (06:35) Mm-hmm. Praveen Bodigutla (06:35) be actually have put more weight on the location and workplace type as opposed to others might be putting more information on seniority and specific aspects of the role. So the how of how the user actually achieves these tasks, in this case the hiring job, that is captured in the procedural memory. So The memory is this layered cake of like conversational, episodic, procedural, and semantic memory which captures information at different granularity and specificity. Ryan Donovan (07:09) Hmm. and I you know, there's the the sort of three end buckets for state, but or or four. but I the it all comes from basically a single data stream, right? Sort of the the discussions, interactions on the site. what's the challenge of extracting these separate sort of behavioral state markers? Praveen Bodigutla (07:38) Right, so if you look at the stream of conversations, so there are two different sets of data sources. One, let's say the interaction that the recruiter or the user has with the agents. And if we talk specifically about that, your context can bloat up as you accumulate these interactions over a period of time. Like think about the hiring process involving multiple steps. First, you have to start with the job description, then refine the job description. Then you are shown certain candidates and then you give certain feedback on that, and then you reach out to certain candidates and you prefer some and archive others. So all of this information gets accumulated. So on runtime, we want to make sure that this is compacted correctly. So we have this ingestion service which, as it's actually looking at this interaction in real-time and near real time, tries to consolidate these. In fixed workflow agents, it's kind of like relatively easier because you know the boundaries of each and every step in the workflow. But as we are moving towards more deep agents and advanced interactions, the the steps can be interlinked. User can first, like the recruiter can first start with, let's say, calibrating a candidate and then go back and refine it and then go back and forth between these. So identifying the right session boundaries, identifying the right interaction subtopics, and then organizing the memory and making sure that it is discoverable. So that stream is challenging in its own way because you have to make sure that you have compressed it, you have not lost information, and then you have accurately represented that information that is persisted. And last but not least we have to retrieve that information too. Now Ryan Donovan (09:24) Right. Praveen Bodigutla (09:24) as as that interaction is going on, I could change my preferences. I could say, you know what, Ryan Donovan (09:29) Mm. Praveen Bodigutla (09:29) I don't want to hire in this particular location. Maybe let's actually look for a different skill. Maybe look for people with complementary skills. So when certain preferences are expressed during the course of conversation, then that brings this concept of like, hey, how do we make sure that the most fresh and recent information gets priority? And if there Ryan Donovan (09:50) Yeah. Praveen Bodigutla (09:50) are any conflicts while we are retrieving the memory and answering the queries that are that the user is posing via the application agent, their accurate, fresh. recent and the conflicts are handled correctly and most importantly in low latency as well. Ryan Donovan (10:07) Yeah. I imagine with with something like that, a recruiter could be hiring for multiple roles. is there a difficulty, complication with sort of like, you know, hiring in multiple with multiple preference sets? Praveen Bodigutla (10:25) there is difficulty, but at the same time, there is this nice carryover effect of preferences from one similar set of roles that the recruiter is hiring for. now, when we talk about the challenge here is we want to first of all understand how is our data or this preference or memory in this case organized. Now, in the hiring assistant case, we we have a natural tree like structure. For some of these preferences that are hired. For example, a recruiter has multiple projects that they're hiring for, and each of these projects can have their individual preferences. So that's the granular leaf level node. And then you can aggregate these preferences at the recruiter level. And then you have this cohort, like multiple recruiters. Let's say they belong to the same company, they're hiring for similar roles. They're sharing of information across these different recruiters belonging to the same cohort. So When we mine this information and organize it, which is aligned with the inherent structure that is present in the data and also in terms of the interactions, then it can actually become a superpower for you to like bootstrap some of these conversations for let's say new recruiters who are coming in, and now they don't have to start from scratch, they already have a blueprint of how their company is actually prioritizing in terms of the roles and the preferences that are expressed. through their hiring process and workflows across the different members of the same cohort. Ryan Donovan (11:55) Mm-hmm. that's…", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.488, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.488}}
{"format": "sequential_text", "title": "Shadow AI emerges from workflow inefficiencies", "text": "[Ed. note: If you listened to a podcast or read an article of ours and want to publish a response, let us know. We’re open to highlighting community views that respond to our work in ways that don’t fit in a comment section, whether you agree or disagree. Reach out at pitches@stackoverflow.com.] The fastest way to create shadow AI is to publish a policy and assume behavior will follow. Developers work under delivery pressure, face ambiguous problems, and reach for tools that help them move. When the approved path feels slow, vague, or disconnected from actual engineering work, people create a faster path for themselves. That tension sits at the center of responsible AI adoption. In Ryan Donovan's recent conversation with Microsoft's Sarah Bird on the Stack Overflow podcast, responsibility centered on impact, accountability, and thoughtful human-AI workflow design. Stack Overflow's developer AI adoption and trust findings show why this operational focus matters: 84% of respondents use or plan to use AI tools, while more developers distrust AI accuracy than trust it. The leading frustration involves outputs that look almost right but require extra debugging. Organizations cannot solve that gap with a document employees read once. They need to make responsible use easier than improvised use. Shadow AI is usually a workflow signal Leaders often describe unapproved AI use as a compliance problem. That diagnosis starts too late. By the time an engineer pastes sensitive material into a public model or quietly installs an unapproved coding assistant, the organization has already failed to provide a credible route for getting the work done. Microsoft's Work Trend Index found widespread shadow AI through bring-your-own tools, with many users reluctant to admit that they apply AI to important tasks. That behavior does not automatically indicate recklessness. It often reflects a practical calculation: the sanctioned process offers less value than the unsanctioned shortcut. The right response starts with curiosity. Which tasks drive developers toward outside tools? What friction blocks the approved option? Which data, context, integrations, or permissions do teams need? A Stack Overflow discussion of monitored gateways and approved AI platforms shows the value of channeling experimentation through infrastructure that supports visibility instead of trying to suppress it through blanket prohibition. When leaders treat every unapproved use as misconduct, developers learn to hide experimentation. When leaders treat it as diagnostic evidence, they can improve the system. Policy must become an engineering interface Good policy defines intent. Good operations translate that intent into decisions a developer can make during ordinary work. The NIST framework organizes AI risk management around four functions: Govern, Map, Measure, and Manage. Those verbs imply ongoing work. Governance should tell a team how to classify a use case, which model and data sources it may use, how to test the result, who owns approval, and what evidence belongs in the development record. A practical policy should answer questions such as these without forcing an engineer to schedule a meeting with a committee: What data may enter each approved tool? Which repositories or systems may the tool access? What level of review does AI-generated code require? Which tasks require a human decision-maker? What should a developer do after finding a harmful, insecure, or unreliable output? When does an experiment become a production system? Developers rank security and privacy concerns as the leading reasons to reject a technology, according to Stack Overflow's technology adoption findings. Clear operational rules therefore support adoption rather than obstruct it. They reduce uncertainty about what responsible use looks like. Put guardrails where work already happens A policy stored in a learning portal competes poorly with an AI assistant embedded in an IDE. Controls need to live in repositories, pull requests, build pipelines, access systems, and deployment workflows. NIST's secure AI development guidance extends secure software practices across the development lifecycle. The same principle should govern enterprise AI use. Teams can place approved model configurations in version control, restrict access by role, scan prompts and outputs for secrets, preserve logs for higher-risk use cases, and require tests before AI-generated changes merge. GitHub's guidance on human oversight for AI-generated code recommends functional checks, context verification, dependency review, collaborative review, and automation where appropriate. This turns the abstract instruction to \"review AI output\" into a repeatable engineering process. The controls should also match AI-specific failure modes. The OWASP risks for generative AI applications include prompt injection, sensitive information disclosure, supply-chain weaknesses, improper output handling, and excessive agency. A team that uses an AI tool to explain code faces a different risk profile from a team that gives an agent write access to production systems. Applying the same approval burden to both creates delay without improving safety. Assign ownership before the tool acts Responsibility becomes blurry when people describe AI as a collaborator, assistant, or agent. The vocabulary sounds useful, but software cannot accept organizational accountability. Every use case needs a named human owner who understands the intended outcome and has enough authority to stop or change the process. That person does not need to inspect every token. The owner must define acceptable performance, determine where human judgment enters, and make sure someone responds when the system fails. The NIST Generative AI Profile for trustworthy deployment emphasizes risk management throughout design, development, use, and evaluation. In practice, ownership should follow that lifecycle. Product leaders own the business decision. Engineering leaders own implementation quality. Security and privacy specialists define relevant controls. Developers own the code they submit. Reviewers own the decision to approve it. Operators own production monitoring and incident response. This division prevents a familiar failure pattern: everyone touches the AI system, yet nobody owns its consequences. Psychological safety functions as a control Teams cannot manage risks they feel unsafe reporting. A developer who notices that an approved tool leaks context, fabricates dependencies, or encourages insecure code needs a credible way to raise the issue without being treated as resistant to innovation. Google's Project Aristotle identified psychological safety as the most important dynamic in its study of effective teams. Google describes it as a climate where people can take interpersonal risks, ask questions, and surface mistakes. That climate matters directly for AI because many failures first appear as weak signals: an odd completion, a suspicious package, an undocumented data path, or a result that seems plausible but conflicts with domain knowledge. DORA research also connects psychologically safe software delivery cultures with stronger performance and resilience. Leaders undermine that advantage when they celebrate adoption numbers while punishing people who question the tools. Managers should ask teams what went wrong, where the workflow encouraged the mistake, and which safeguard would help next time. They should avoid asking why a particular developer \"trusted the AI.\" That framing personalizes a system failure and teaches everyone else to stay quiet. Train developers for their actual decisions A generic AI awareness session sits too far from the choices developers make under pressure. Stack Overflow's developer trust analysis frames effective use as a skill that includes structuring prompts, evaluating outputs, and integrating generated code into existing systems. Effective AI training for enterprise teams should resemble a license to operate. It should cover the approved tools, permitted data, common failure modes, review expectations, escalation route, and concrete examples from the organization's own technology environment. A backend engineer needs practice checking generated database migrations, authentication logic, and dependency choices. A data engineer needs practice protecting sensitive records and validating transformations. An engineering manager needs to know when a pilot requires security, legal, or architecture review. A platform team needs to know how to observe agent behavior and constrain permissions. Stack Overflow's developer learning patterns for AI tools show that developers actively build AI skills through multiple resources, including AI-enabled tools themselves. Organizations should use that existing appetite. Give teams sandboxed exercises, flawed outputs to review, examples of acceptable prompts, and internal patterns they can reuse. Training should produce artifacts inside the workflow: repository instructions, review checklists, reusable test suites, approved prompt patterns, and documented examples. A certificate proves attendance. These artifacts shape behavior. Measure outcomes instead of tool activity Leaders often measure AI adoption through licenses assigned, prompts submitted, or weekly active users. Those metrics reveal activity, but they say little about engineering value or responsible use. The 2024 DORA research found that higher AI adoption correlated with improvements in documentation quality, code quality, and review speed, while also identifying possible negative effects on software delivery performance. Those mixed effects of AI on development performance support a more disciplined measurement approach. Teams should evaluate a defined workflow before and after introducing AI. Useful measures may include cycle time, escaped defects, rollback rate, security findings, review burden, documentation quality, incident volume, developer satisfaction, and time spent correcting AI output. The relevant measures depend on the task and the risk. Stack Overflow's survey also found that agents indicate gains in individual productivity but not team collaboration. That difference matters. An engineer may complete a local task faster while shifting verification, integration, or maintenance work onto colleagues. Responsible measurement follows the work across the team instead of stopping at the first apparent gain. Make the safe path the fast path Developers will use AI when it helps them solve real problems. Governance succeeds when it makes that use visible, testable, and supportable. The organization should provide approved tools with useful context, straightforward access, clear limits, and fast escalation. It should encode workflow design for people and agents in repositories and automated checks. It should require more review as data sensitivity, autonomy, reach, and reversibility increase. It should protect people who report failures. It should measure team outcomes rather than count clicks. Tool vendors make the same point in their own guidance. GitHub tells users to treat Copilot as a tool rather than a replacement and to review and validate generated responses. CISA's secure-by-design principles similarly call for organizations to build responsibility into product design instead of transferring the full burden to end users. The central lesson is simple. Responsible AI depends less on whether an organization has a policy than on whether its daily system of work makes responsible behavior practical. Leaders who want durable AI adoption at work should design the approved path so developers can move quickly without surrendering judgment, accountability, or engineering discipline. Dr. Gleb Tsipursky, a behavioral scientist called the “Office Whisperer” by The New York Times, helps tech-forward leaders stop overpaying for AI while boosting engagement and innovation. He serves as the CEO of the AI…", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.374, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.374}}
{"format": "sequential_text", "title": "التوافق بين التحديد والمرنة يقلل التكاليف ويوضح الهدف", "text": "I keep seeing the same idea in conversations about agents: Detailed specs are old-world overhead now. Give the model a rough goal, let it explore, fix what comes back, move on. It sounds efficient but it also hides the cost. A simple prompt looks cheap and tempting because it gets implementation started right away. Then the correction loops start. You review output, clarify intent, ask for changes, rerun tests, find the next gap, and do it again. Someone still has to decide whether the result matches the real goal. That person becomes the oracle. At the other extreme, full formal specification is obviously expensive up front. Writing acceptance criteria, contract tests, or behavior-driven development (BDD) scenarios takes real effort. But the downstream cost is different because more of the oracle is executable. A test checks the same condition every time. It doesn’t get tired, rushed, or optimistic five minutes before lunch. That is the actual trade-off. The question is not whether specification is good or bad. It’s where the minimum total cost sits. For most agentic work, it’s somewhere in the middle: enough structure to constrain the work, enough examples to make intent concrete, and enough executable checks that review does not turn into guessing. Zero spec is not intelligent and lean; it’s just costly vibe-coding. The bottleneck moved, not disappeared Software engineering was never mainly about typing or even producing code. It was about deciding what should exist, what should never happen, which trade-offs matter, and what “done” means once the problem touches the real world. For years, teams discovered missing specification through human friction. A reviewer noticed an edge case, QA found the path nobody described, a senior engineer carried half the real requirements in his head and translated them one meeting at a time. None of that was elegant, but it did force ambiguity into the open. Agents change that fundamentally. They make implementation much cheaper and much faster. It also means an underspecified idea can turn into a plausible system before anyone has really agreed on what the system is supposed to mean. In the old world, vague requirements ran into human slowness. In the agent world, vague requirements run into machine speed. That’s why specification suddenly feels important again. It was always important. We just used implementation cost as a crude forcing function and called the result process. Writing the spec is not enough This is the part I see people skip most often. They talk as if the sequence is simple: write the spec, then let the agent implement it. The missing step is the expensive one. The spec itself needs review. Even a careful spec can fail in familiar ways. It can contradict itself or cover the happy path and say nothing useful about retries, rate limits, or partial failure. It can describe behavior that sounds precise but cannot actually be verified. And sometimes it is precise in exactly the wrong way: it says what you wrote, not what you meant. When an agent executes a flawed spec faithfully, the failure gets harder to diagnose. The implementation may look coherent. It may even pass the checks you provided. But the real problem lives upstream, in the spec, so fixing it means unwinding code and reasoning together. That’s why I think spec validation deserves its own line item. Before implementation starts, someone needs to ask a few plain questions. Is this internally consistent? Is it complete enough for this task? Which parts are testable? Where are we still depending on human judgment? Which failure modes are missing because everyone silently assumed them? Agents can help here, but only if we use them for something more useful than “write requirements.” That prompt usually produces polished fog. A better prompt is much more specific: Draft the smallest spec that would let another agent implement this safely. Include assumptions, nongoals, acceptance criteria, edge cases, observable outcomes, and open questions. Mark which claims can become automated tests and which still require human review. After that, hand the draft to a different agent and tell it to attack the result: Find contradictions, ambiguous terms, hidden dependencies, untestable claims, missing failure modes, and places where an implementation could pass the written criteria while still violating the intent. Even that simple workflow lowers the cost of getting to a spec that is worth human judgment. Why multi-agent systems need stronger contracts A single agent working on a small, bounded task can often recover from loose instructions. The loop is tight, the blast radius is local, and a human can usually steer it back on course when it drifts. Humans can even easily spot the drift to begin with. Multi-agent systems are a very different problem. Once one agent’s output becomes another agent’s input, interpretive drift starts to compound. Agent B does not know Agent A misunderstood a requirement by 10%. It just treats the output as ground truth and keeps going. By the time a human sees the result, the original mistake may be buried under several layers of competent-looking work. At that point, the spec is no longer just guidance but more like a contract. That contract needs more than a paragraph of intent. It needs schemas, invariants, allowed ambiguity, validation rules, and explicit failure behavior. In many cases, it also needs contract tests, typed interfaces, and machine-checkable handoff formats. The handoff is part of the product, which is less glamorous than people hoped, but much closer to reality. This is also where BDD and executable acceptance tests belong. Their value is not just the methodology, it’s that they move part of the human oracle into something repeatable. When behavior is stable enough to specify precisely, an executable spec is often cheaper than another round of review. A spec should have an expiration date There is another failure that teams make here: It shows up when they keep pushing on the specification curve as if more text is always safer. It is not. At least for current models it’s not. Chroma’s work on context rot makes the first part of the problem clear: Model performance gets less reliable as the input grows, even on simple tasks. In coding projects there is a second problem on top of that. The more design prose, examples, plans, comments, tickets, and old acceptance criteria you stuff into the context, the less obvious it becomes which parts are instructions and which parts are artifacts. I wouldn’t call this prompt injection in the security sense. Nobody is trying to attack the model. It’s closer to self-inflicted instruction drift. The context contains old design intent, current implementation, half-valid examples, generated plans from three sessions ago, and maybe a stale software design document that still describes classes that no longer exist. At that point, the model is not reading one spec, it’s averaging across competing sources of truth. That’s when overspecification stops helping and starts confusing the model. The agent can no longer tell whether a paragraph is an active requirement, a historical note, or something the code has already replaced. A design document is useful early because the code doesn’t exist yet. Later, it needs to shrink. Once interfaces, tests, and invariants are real, the detailed build plan should start disappearing. “Keep the parts” code is bad at expressing on its own: business rationale, non-goals, safety constraints, external contracts, and the few invariants you do not want rediscovered by trial and error. Delete the prose that just restates what classes and methods already do. Otherwise, you end up with two specs. Humans will complain about that in review. Agents will often try to obey both. APIs can make code behave like spec There is also a more optimistic version of this story. Some codebases reach the “code is the spec” point faster than others, and API design is a big reason why. If an internal API hides behavior behind conventions, weakly typed parameters, setup magic, and generic errors, an agent cannot treat the code as the spec. It has to reconstruct the rules from scattered prose and trial and error. That’s slow for humans and worse for models. The opposite is also true. An API with explicit names, task-level methods, strong types, readable validation, useful examples, and actionable errors gives the agent something concrete to stand on. If the agent can inspect the surface area, see what a method does, understand what input is legal, and recover from errors without guessing, then the code carries much more of the specification load by itself. This is where the AI-friendly API design ideas matter in practice. Explicit discoverability beats convention. Methods should line up with real tasks instead of forcing the agent through a dozen fragile steps. Types and validation should show what legal input looks like. Error messages should point to the next fix, not just announce failure. Introspection and examples help the model learn the shape of the API from the codebase it already has. Performance transparency matters too, because an agent will happily write a correct and terrible loop around an expensive call if the API gives it no clue. This isn’t only about public SDKs. It applies to internal service boundaries, library clients, repository abstractions, and even the helper classes in a large monorepo. The easier an API is to discover and inspect, the easier it is for an agent to treat the code as the authoritative spec instead of dragging more prose into the context. I’ve written about all this before in more depth if you’re interested. Where to invest What I strongly believe is that there is no single right amount of specification. The answer depends on the kind of work you’re doing. For a small, well-bounded task, the sweet spot is usually structured intent: the goal, a few examples, nongoals, and clear acceptance criteria. That is often enough to keep the agent productive without making setup heavier than the task. For deterministic work such as CRUD flows, API integrations, and data transformations, the optimum moves to the right. These domains are easy to constrain and easy to test. More specification pays for itself quickly because it cuts repeated review and rework. This is where BDD, contract tests, and executable acceptance criteria help most. For exploratory work such as architecture options, research synthesis, or novel product ideas, the optimum moves left again. Over-specification can kill the very flexibility that makes the agent useful. In that case, I would rather specify boundaries than outcomes: what must be true, what must not happen, what evidence is required, and which decisions still need a human. For multi-agent pipelines, the optimum moves right once more. Every boundary between agents needs a contract. Without that, you aren’t coordinating a system. You’re stacking interpretations and hoping they cancel out. The common rule across all four cases is simple: Validate the spec before you scale the implementation. What survives from Agile and XP I do not think agents make Agile or XP irrelevant. They make the useful parts easier to separate from the parts people were already tolerating. The first casualty is the ceremony that existed mostly to coordinate human effort hour by hour. Daily status meetings, inflated backlog rituals, and estimates presented with more confidence than information do not get stronger because an agent wrote the code. If anything, they get weaker. Agents can change the shape of a task so quickly that old effort estimates become fiction even faster than before. That doesn’t mean planning disappears. It means planning has to stop pretending it can predict implementation cost with the same comfort it had when code was the slow part. What survives from Agile is the feedback logic. Short cycles still matter. Thin vertical slices still matter.…", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.456, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.456}}
{"format": "sequential_text", "title": "AI Agents Redefine Web's Future and Content Needs", "text": "Get rid of your CAPTCHA, the future of the web is bots Ryan chats with Brian Alvey, CTO at WordPress VIP, about how AI agents are changing the business models of the web, what parts of how we build our sites won’t survive our current digital evolution, and why your site will always need structured content. WordPress VIP is the content platform you know and love, built for enterprise.", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "AI transforms project management from manual tasks to strategic roles", "text": "In the early days of software engineering, project management was synonymous with the \"Gantt chart warrior\", someone whose primary value was the manual tracking of dependencies and the rhythmic pestering of engineers. Today, that world is vanishing. As engineering organizations scale, we are quickly integrating generative AI, large language models (LLMs), and agentic workflows into our delivery pipelines. The integration of artificial intelligence into technical project management is not a job threat from science fiction; it is a fundamental transformation in how we build, ship, and maintain complex systems. Here is how the discipline of technical project management is evolving from administrative oversight into a highly strategic role: the AI-augmented Systems Architect. The End of the \"Coordination Challenge\" and the Shift to Predictive Orchestration Walk into almost any tech company today, and you will find highly skilled project managers spending up to 60-70% of their time dealing with a \"coordination tax\". This means they are manually updating spreadsheets, reconciling conflicting state data across disparate tools, and generating status reports that are obsolete the moment they are exported. Microsoft’s latest productivity research shows that by 2030, AI will automate 80% of these routine administrative tasks. In our engineering organization, we've watched this transformation shift our operations from Reactive Management (finding out what broke yesterday) to Predictive Orchestration (knowing what will break tomorrow). The technical aspects behind this shift are significant. Status tracking, which once required expensive, synchronous daily standups, now happens automatically through continuous telemetry, that is, AI agents ingest data directly from Git commits, pull request (PR) comments, and continuous integration/continuous deployment (CI/CD) logs to create real-time state assessments. Risk identification no longer relies on a PM's \"gut feel\" to spot patterns across hundreds of tickets; instead, ML models analyze codebase complexity, historical delivery patterns, and team velocity trends to run Monte Carlo simulations on project outcomes. The result? The administrative burden on our technical PMs has dropped to less than 30% of their time. Visualizing the Shift: Traditional vs. AI-Augmented Delivery AI is shifting project managers’ time from manual coordination to strategic work. Status tracking moves from manual check-ins and spreadsheets to automated Git and Jira telemetry, reducing time allocation from 25% to 8%. AI-driven forecasting cuts risk management from 15% to 5%, while dynamic capacity planning reduces resource allocation from 10% to 5%. This efficiency gives project managers more time for higher-value responsibilities. Strategic planning increases from 10% to 25%, and stakeholder alignment rises from 8% to 18%. The result is a role focused less on administration and more on business outcomes, informed decisions, and human collaboration. The Rise of Agentic Workflows and the Hybrid Workforce The conversation about AI often focuses on generative tools, such as using an LLM to draft a summary or a meeting agenda. However, the real advancement in deep tech delivery is the emergence of Agentic AI. At leading organizations, we are using multi-agent systems that not only analyze data but also take independent action. Picture an AI \"Project Assistant\" closely integrated into your operations. It detects, through HR systems or Slack status, when a key engineer is out sick. The agent independently analyzes the sprint backlog, identifies the dependency chain, and quickly suggests a re-prioritized workload to the PM for easy approval. This change significantly reshapes the PM's role. They are no longer just overseeing a team of human developers. Instead, they become a Systems Architect, coordinating a workforce made up of both humans and intelligent agents. The PM sets the guidelines, makes sure the AI trust frameworks are in place, and supervises the implementation. As we often remark, the aim of AI in project management is not to replace the pilot. It’s to offer a much more advanced autopilot, allowing the pilot to concentrate fully on the destination. Implementation Reality: The Messy \"Garbage In, Garbage Out\" Problem In practice, the implementation on a bustling engineering floor is incredibly messy. Implementing AI exposes hidden operational debt, and technical leaders must be prepared for the friction. The first major challenge is data quality. AI models are only as effective as the data they process. When we first deployed automated status reporting, the models hallucinated or failed entirely because our engineering teams were fundamentally inconsistent. One team marked a ticket \"done\" when the code was merged; another when it passed QA; another only when it shipped to production. This wasn't an AI failure; it was an organizational discipline failure that the AI merely exposed. The second, arguably more dangerous hurdle, is algorithmic over-reliance. When PMs embrace AI too enthusiastically, they stop questioning the output. In one instance, our automated scheduling tool repeatedly recommended deploying code late on Friday afternoons. Why? Because the ML model recognized a historical pattern of \"spare capacity\" at that time. What the algorithm failed to understand was context: those late-day deployments weren't planned releases; they were emergency hotfixes. In another case, an AI agent flagged a low-priority bug as a high-complexity risk, recommending we pull a senior backend engineer off a core feature to address it. A human PM intervened, realizing the complexity score was artificially inflated simply because the original bug report was terribly written, not because the underlying code issue was difficult. Critical evaluation and AI literacy—understanding the difference between correlation and causation, and recognizing training data bias are now mandatory engineering skills. Irreplaceable Human Skills: Engineering Empathy & Strategic Judgment AI helps with tasks but can’t take over leadership, tough decisions, or teamwork. Companies need to train people in both AI tools and these core human skills to succeed. If an AI can balance the budget, predict the bottlenecks, and track the commits, what is left for the human? The answer lies in the \"art\" of software delivery: navigating human complexity and applying strategic context. AI excels at logic and pattern recognition, but it fails entirely at emotional intelligence (EQ), organizational politics, and contextual judgment. Consider a scenario where an AI system flags a two-week delay in a critical feature launch, pointing to low engineering velocity. The raw telemetry is accurate, but it misses the entire strategic picture. The PM actually intentionally negotiated that delay with the product team because a major zero-day security vulnerability was discovered in an upstream dependency. The PM knew that communicating a delay to the executive board framed around security hardening would secure immediate buy-in, whereas framing it as an engineering slowdown would trigger panic and micromanagement. No algorithm can read a room like that. No AI can resolve a bitter dispute between a product manager demanding feature completeness and an engineering lead drowning in technical debt. Furthermore, AI can detect that a team's sprint velocity dropped by 15%, but it cannot know that the drop is because a core developer is dealing with a family health crisis, or because the team is suffering burnout after six months of a grueling remote deployment cycle. Building psychological safety, establishing trust, and knowing when to push a team versus when to give them breathing room remain exclusively human capabilities. AI makes human skills even more important. Skills like communication, collaboration, leadership, and good judgment are still essential and cannot be replaced by AI. Recent surveys show executives rank communication as the top in-demand skill. The Future Matrix: Specialized Roles in the AI Era Looking ahead to 2030, the role of project manager will probably turn into an entry-level job, fully supported by AI assistants. As routine coordination becomes entirely automated, AI agents will automatically resolve resource conflicts, schedule meetings only when needed, and update stakeholders. The project management field will likely split into more specialized areas. We are already seeing the emergence of these specialized roles: - AI Operations Managers: Deep tech PMs with ML fundamentals who configure, train, and optimize the AI project management systems and agents themselves. Their role relies heavily on data science and systems architecture. - Strategic Program Directors: Leaders focused on multi-year roadmaps, enterprise business alignment, and executive communication. They use AI strictly for data ingestion, relying on their immense business acumen to make macro-level pivot decisions. - Team Enablement Managers: Hyper-focused on the human element—removing blockers, optimizing developer experience (DevEx), and coaching engineering teams. They rely on empathy and organizational psychology to boost performance. Conclusion: A Smarter, More Human Way Forward The use of artificial intelligence in deep tech project management is a major driver for improvement across the industry. AI is not taking away project managers' jobs; it is removing the repetitive, tedious tasks that they have always disliked. By transferring the tracking, reporting, and resource management to smart systems, we allow human leaders to focus on the delivery side of their roles. Project managers who see AI as a threat are asking the wrong question. They should not be wondering, \"Will AI replace me?\" Instead, they should be asking, \"How can I use this digital system to become the strategic leader I've always wanted to be?\" To remain relevant, project professionals must quickly increase their AI skills, gain knowledge across business, data, and technology areas, and develop the unique abilities needed for high-stakes decision-making and understanding human emotions. The future of software delivery is not about humans versus machines. It involves the human project leader, supported by an autonomous system, achieving technical excellence with unmatched speed and clarity. Author’s Note: This article was supported by AI-based research and writing, with Claude 4.5 assisting in the creation of text and images.", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.471, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.471}}
{"format": "sequential_text", "title": "From PHP to team lead of agents: rethinking…", "text": "In this episode, Eira May and Stack Overflow Director of Platform Engineering Peter O'Connor talk with Andi Gutmans about the throughline between democratizing web development with PHP and democratizing software development with agents today. Andi makes the case that every individual contributor is becoming “a team lead of agents” and walks through how that reshapes code review, interviewing, and the balance of human versus agent judgment. He also explains why he thinks the biggest bottleneck left isn't the models, but the challenge of getting an organization's data into a state where agents can actually reason over it. The discussion also: - Covers how Google is changing its own interview process to evaluate how candidates reason with and guide agents, rather than how well they can hand-code a solution alone. - Explores the \"human in the loop, agent in the loop, agent on the loop\" framework for deciding where review actually needs to happen — and why that's fundamentally a risk-management question, not a trust-in-AI question. - Uses the Waymo safety-data-versus-perception gap as an analogy for why organizations (and individuals) sometimes resist agent autonomy even when the numbers favor it. - Introduces Google's \"borderless lakehouse\" concept and the shift from human data stewardship to agent-driven ontology building. Notes: TRANSCRIPT Eira May: Hello, and welcome to Leaders of Code. This is a segment on the Stack Overflow Podcast where we get senior engineering leaders together and talk about the work they're doing, how they go about building their teams, and the biggest challenges they're dealing with right now. My name is Eira May, and I am the B2B editor at Stack Overflow. I'm here with my colleague, Peter O'Connor, who is director of platform engineering here at Stack. Hi, Peter. Peter O'Connor: Hello, how's it going? Eira May: It's going really well. Pretty good for a Monday. Today we have a guest I'm really excited about. We're talking with Andi Gutmans, who is head of Agentic Data Cloud at Google, and Andi is one of the creators behind PHP 3, I think was a college extra credit project, the way I heard it, and now it turns out it's the Bedrock of web development. Andi, welcome to the show. Andi Gutmans: Hey there. Thanks for having me. Eira May: Yeah, thank you so much for joining. I wanted to start with a question for you, Andi, and then I'll let you and Peter kind of take it from here. You helped build tools that made the whole just write code and ship it kind of possible for a generation of web developers. So I'm wondering, how does the shift to agent scale feel from the perspective that you're coming from, the experiences that you've had? Does that feel like a huge change? Does it feel more like a natural progression? Andi Gutmans: To me it feels more like a natural progression. So I think one of the things that was really exciting back in the day when we worked on PHP is we really democratized web development. And actually one of the things that was really impactful is you didn't have to be a computer science graduate to actually use PHP to build a website. So as long as you were a bit technically astute, you could actually build websites. I even had, throughout my career, folks like doctors telling me like, \"Oh, I used your language and I built a website for my office,\" and so on and so forth. And so I think that was a really important time when we made web development accessible to anyone, not only computer science graduates. I think you can think about this moment in a very similar vein where agents are actually enabling lots of practitioners to drive outcomes that are remarkable. My sister, she's not technical, she's a lawyer by degree, but she's been building websites with Lovable as an example, and amazing websites. So you can almost think about this, this is like PHP, but way, way better on pretty much every dimension. And then I think the other piece, the other dimension that really matters is the trust and the security side where I think with agentic development, the best practices can actually be now driven by agents. Where back in my day, one of the issues you had in having non-computer science graduates building websites is they build insecure websites or lots of bad code out there. So I think there's this whole new step up we have right now that is really exciting. Peter O'Connor: Interesting. So I come from the platform engineering point of view, Andi, and it's building tools for those developers. So their lives are even easier. I'm trying to think about when we try to make it easier for them, what are some of the principles when you're thinking about how we think about AI and how to guide it properly and get people to use those tools properly? Do you have certain guardrails or advice that you're thinking about like, \"Hey, if you want to do this right, here's some patterns to follow.\" How do you think about that? Andi Gutmans: Yeah, no, that's a great question. Look, I think the same things matter when you're developing with AI as when you're not developing. There is are you delivering the right level of trust? So are you getting to the right outcomes? It's secure, it's governed. All these things matter just as much, if not more as before. That cost matters a lot, making sure it's easy to use. So I would say that dimensions are probably very, very similar in manner. But the change right now is agents can do so much work autonomously that as we think about the guardrails and how we make sure that we are getting to those right outcomes in the right way, we have to approach that a bit differently. But I think it is still the same kind of fundamental things that actually matter. This is where making sure that you have the right data to activate these agents, that you have the right decision-making around risk-taking on when is it human in the loop? When is it agent in the loop? When is it agent on the loop? You kind of have to make decisions on how you want to operate, but that's actually not that different from engineering decisions that have had to be done in the past on other dimensions. Peter O'Connor: For sure. It's really good to hear the data matters and make sure we guide things properly and the human still matters. A place I hear on my side a lot, which is totally understandable from engineers, is the craft of code is very important to people. And so when I allow an agent to do it, they may not do it exactly as I want because they're not following the pattern exactly as I'd like. Are the patterns in the code craft, in your opinion, just as important as well? Or should we take a step back and say, \"Maybe that doesn't matter as much as it used to?\" Andi Gutmans: Yeah, I mean even when you look to the pre-agentic development, it mattered less what language you're coding in. I mean, it mattered to a certain degree, but what really mattered was do you understand the business problem? Are you building a sound architecture? Do you have the operational excellence to scale? And so what ended up happening was because you had to do a lot of manual coding, you maybe spent 80% of your time coding 20% on these other things, as opposed to now you can actually spend more of your time making sure you're getting to the right outcomes. So the way I think about this is the value just kind of moves now towards making sure that you're using your judgment on how to guide the agents. You're also making sure that you're reviewing the work that agents are doing in the appropriate manner. For example, I coded something, the agent built a thousand tests for me, and then I had another agent critique those tests and I found out those tests were actually not very good and I had to kind of improve on them. So it still required my judgment. It's just that I was doing less coding as part of that and more designing and orchestrating. And really the way I think about it is every individual contributor now becomes a team lead of agents. Peter O'Connor: Interesting. I think that's a really, really good position to think about things. And I really like the idea of a team lead of agents. How do you see the scope of the knowledge a person needs to have in order to do that work? Because when I think a team lead, you're talking about a senior person. How do we make sure people have those skills? Is there a pipeline problem that we're going to end up running into? Is there a skills problem? Andi Gutmans: I think it's going to resolve itself because I think what's going to happen is even as you think about kids going to college, doing a computer science degree and so on, how we learn computer science is also going to change. Of course, it's critical for folks to have judgment around how a system is built, how a system runs, how to scale. So a lot of these things are going to be the same. But if you think about it, they could potentially take on university projects that are much more complex and a greater scale with agents than if that were hand coded now. So I think what's going to naturally happen is the folks coming out of college are already going to gain that superpower as they go through college, and they're already going to be conditioned to be the team lead of agents. So I definitely think that that's just going to be a natural progression of how things work. It's not that we're not going to need new entrants to the workforce coming out of computer science degrees. Peter O'Connor: Yeah, I really agree with that very heavily. I think I was on a podcast to myself and actually did an interview about interviewing techniques. And I said one of the biggest changes that we're going to have to really look at is it's not so much that you solve some abstract problem very well. I want to hear about reasoning around it and I want to understand how would you orchestrate that problem at a grander scale? And that's hard. Andi Gutmans: Yeah. By the way, we're changing our interview process. So it's not going to be about having an engineer come and build the quick sort by hand and us looking at their code. It's actually giving them an opportunity to use Gemini, to use the agent, give them a problem, see how they're approaching it, how they think, reason through the problem, how they're actually guiding the agent. So I think this is just a natural progression of us having the opportunity to use agents at work. Peter O'Connor: They cannot agree more. And I think for me, it also reveals one of the fundamental things I keep seeing in interviews is someone who's got aptitude, they're willing to try and learn. They have an energy. You can actually see them solving the problem and you get to understand their problem space design. It's really exciting as opposed to, \"Yeah, okay, great. Here's the 20th quick sort I've done.\" Like, \"Okay. Great.\" Andi Gutmans: Exactly. Peter O'Connor: Yeah, not fun. So maybe taking a step back, you talked about the PHP work you've done a little bit and how we try to get people who can't code to code again. I'm not sure if you're aware, and I'm sure you are, but I'll say I was reading a quote by Linus Torvalds recently where he was saying, \"Hey, engineers are...\" I'm paraphrasing it. He was like, \"Hey, engineers are concerned that they don't understand the code they're writing.\" And his response was, \"They never did.\" Have you heard that recently? Does that mean anything to you to hear that, \"You know what? You just never did really know the code you wrote.\" Does it matter? Andi Gutmans: Yeah. I'd say most engineers who've worked on large scale projects never really had an ability to understand 100% of the code anyway. They kind of understand the subset of code that they were working on, maybe some of the adjacent modules, but maybe Linus understands the full Linux kernel end-to-end. But I would say in most enterprise settings, you usually don't have a single engineer who knows every line of code. So I think to a certain degree, that's been the environment. I actually…", "metadata": {"source": "https://stackoverflow.blog/feed/", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.427, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.427}}
{"format": "sequential_text", "title": "The Many Faces Of September (2026 Wallpapers Edition)", "text": "The Many Faces Of September (2026 Wallpapers Edition) For more than 15 years already, our monthly wallpapers series has been the perfect opportunity for creatives of all backgrounds to put their skills to the test. You don’t have to meet stakeholder or client requirements; for a change, it’s just you, exploring your ideas and bringing them to life in your own, unique style. Since we first embarked on this wallpapers journey, so many talented folks from all across the globe have accepted the challenge, and this September is no exception. Created with love by the community for the community, all the wallpapers in this collection come in a variety of screen resolutions and can be downloaded for free. A huge thank-you to everyone who tickled their creativity and shared their designs with us — this post wouldn’t be possible without your kind support! If you’d also like to be featured in one of our upcoming wallpapers posts, please don’t hesitate to join in. We can’t wait to see your story come to life! Happy September! - You can click on every image to see a larger preview. - We respect and carefully consider the ideas and motivation behind each and every artist’s work. This is why we give all artists the full freedom to explore their creativity and express emotions and experience through their works. This is also why the themes of the wallpapers weren’t anyhow influenced by us but rather designed from scratch by the artists themselves. Welcome Autumn “That crisp, golden shift in the air when the first fallen leaves begin to blanket the streets of Novi Sad always brings a quiet transition into a slower rhythm. The goal was to capture that cozy, enveloping feeling of the changing seasons through a simple illustration, the way a woodland canopy naturally forms an archway, framing the workspace in rich amber, rust, and deep burgundy.” — Designed by Popart Studio from Serbia. - preview - with calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 September On Repeat Designed by Ricardo Gimenes from Spain. - preview - with calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 A Stream Of Consciousness Designed by Ricardo Gimenes from Spain. - preview - with calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 Autumn Rains “This autumn, we expect to see a lot of rainy days and blues, so we wanted to change the paradigm and wish a warm welcome to the new season. After all, if you come to think of it: rain is not so bad if you have an umbrella and a raincoat. Come autumn, we welcome you!” — Designed by PopArt Studio from Serbia. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Funny Cats “Cats are beautiful animals. They’re quiet, clean, and warm. They’re funny and can become an endless source of love and entertainment. Here for the cats!” — Designed by UrbanUI from India. - preview - without calendar: 360x640, 1024x768, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1680x1200, 1920x1080 Terrazzo “With the end of summer and fall coming soon, I created this terrazzo pattern wallpaper to brighten up your desktop. Enjoy the month!” — Designed by Melissa Bogemans from Belgium. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Summer Ending “As summer comes to an end, all the creatures pull back to their hiding places, searching for warmth within themselves and dreaming of neverending adventures under the tinted sky of closing dog days.” — Designed by Ana Masnikosa from Belgrade, Serbia. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Cacti Everywhere “Seasons come and go, but our brave cactuses still stand. Summer is almost over and autumn is coming, but the beloved plants don’t care.” — Designed by Lívia Lénárt from Hungary. - preview - without calendar: 320x480, 800x480, 1024x768, 1024x1024, 1280x1024, 1400x1050, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Flower Soul “The earth has music for those who listen. Take a break and relax and while you drive out the stress, catch a glimpse of the beautiful nature around you. Can you hear the rhythm of the breeze blowing, the flowers singing, and the butterflies fluttering to cheer you up? We dedicate flowers which symbolize happiness and love to one and all.” — Designed by Krishnankutty from India. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Stay Or Leave? Designed by Ricardo Gimenes from Spain. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Listen Closer… The Mushrooms Are Growing “It’s this time of the year when children go to school and grown-ups go to collect mushrooms.” — Designed by Igor Izhik from Canada. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 2560x1600 Who Designed by Ricardo Gimenes from Spain. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 Hungry Designed by Elise Vanoorbeek from Belgium. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1440x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Maryland Pride “As summer comes to a close, so does the end of blue crab season in Maryland. Blue crabs have been a regional delicacy since the 1700s and have become Maryland’s most valuable fishing industry, adding millions of dollars to the Maryland economy each year. The blue crab has contributed so much to the state’s regional culture and economy, in 1989 it was named the State Crustacean, cementing its importance in Maryland history.” — Designed by The Hannon Group from Washington DC. - preview - without calendar: 320x480, 640x480, 800x600, 1024x768, 1280x960, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1440, 2560x1440 Lucha Libre “This month is Mexico’s independence day and I decided to illustrate one of the things Mexico’s best known for: the Lucha Libre.” — Designed by Maria Keller from Mexico. - preview - without calendar: 320x480, 640x480, 640x1136, 750x1334, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1242x2208, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 2880x1800 A Cozy Evening “The leaves are changing their colors now, but the nights are still warm. There’s something different tonight… do you feel it? It’s like the air tastes like a soft marshmallow and you’re sitting by a warm fire in the middle of the forest, while the nature that surrounds you is transforming. It’s ok, small changes are normal and all you can do is sit back, look at the stars, and embrace the world that evolves around you.” — Designed by Creative Pinky from the Netherlands. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Go Bananas Designed by Ricardo Gimenes from Spain. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 Summer Is Leaving “It is inevitable. Summer is leaving silently. Let us think of ways to make the most of what is left of the beloved season.” — Designed by Bootstrap Dashboards from India. - preview - without calendar: 360x640, 1024x768, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x900, 1680x1200, 1920x1080 Still In Vacation Mood “It’s officially the end of summer and I’m still in vacation mood, dreaming about all the amazing places I’ve seen. This illustration is inspired by a small town in France, on the Atlantic coast, right by the beach.” — Designed by Miruna Sfia from Romania. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1440x900, 1440x1050, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Rainy Flowers Designed by Teodora Vasileva from Bulgaria. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1280x720, 1280x960, 1280x1024, 1400x1050, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Colors Of September “I love September. Its colors and smells.” — Designed by Juliagav from Ukraine. - preview - without calendar: 320x480, 1024x768, 1024x1024, 1280x800, 1280x1024, 1440x900, 1680x1050, 1920x1080, 2560x1440 Finding Jaguar “Nature and our planet have given us life, enabled us to enjoy the most wonderful place known to us in the universe. People have given themselves the right to master something they do not fully understand. We dedicate this September calendar to a true nature lover, Vedran Badjun from Dalmatia, Croatia, who inspires us to love our planet, live in harmony with it and appreciate all that it has to offer. Amazon, Siberia, and every tree or animal on the planet are treasures we lose every day. Let’s change that!” — Designed by PopArt Studio from Serbia. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Early Autumn “September is usually considered as early autumn, so I decided to draw some trees and leaves. However, nobody likes that summer is coming to an end, that’s why I kept summerish colors and style.” — Designed by Kat Gluszek from Germany. -…", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.359, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.359}}
{"format": "sequential_text", "title": "Data visualization needs UX to drive actionable insights", "text": "Rethinking Data Visualisation: A UX Approach To Dashboards That Actually Drives Decisions In organisations today, data has never been more available. Dashboards and performance decks exist for almost every function — sales, product, marketing, operations — and the tools to build them have never been more accessible. And yet, in weekly standups and quarterly reviews, the same thing happens constantly: someone shares the numbers, the room nods, and the meeting ends without a decision or clear direction. When that happens, the data usually takes the blame. The numbers weren’t granular enough, the dataset wasn’t complete, we need more information before we can act. But the data is almost never the problem. The reality is that nobody designed it to deliver insights. The chart was built from what was available, not from the question that needed answering. The audience was assumed rather than understood, and what should actually change as a result of seeing this data — that question — was never asked at all. Data visualisation and UX are solving the same underlying problem: both are trying to move the right information to the right person in a way that changes something. The vocabulary is different, but the underlying challenge is identical, and the moment you start treating them as complementary disciplines is the moment dashboards stop being a passive collection of charts and start doing something functional. For designers who work with data, analysts who present to non-technical audiences, and marketers who need their numbers to do more than sit in a slide, this read is for you. The Chart Was Never The Whole Story In 1973, the statistician Francis Anscombe (PDF) published a paper that made a quiet but clarifying point. He constructed four datasets that are statistically identical: same mean, same variance, same correlation coefficient, and same regression line. Run the numbers on any of them, and they are identical. Plot them, and they could not be more different. Anscombe’s lesson to statisticians was about diagnosis: visualisation reveals the operational truth that raw numbers conceal. But visualisation isn’t just diagnostic; it is also communicative. The form you choose is where understanding either emerges or gets lost in the noise. Does your audience walk away with numbers, or with a story they’ll quote and talk about? One of the most striking examples is Visual Capitalist’s History of Pandemics. Instead of burying the reader in a massive data table of casualty counts, it maps the death toll of major historical pandemics using a proportional bubble layout on a single timeline. Before your brain reads a single number, your visual system grasps the sheer scale of the Black Death relative to everything else on the page. The right visualisation does not just plot the data but makes the story impossible to miss. Edward Tufte codified a foundational principle for the craft with his data-ink ratio: every mark on a chart should serve the data, not decorate it. It remains a widely used framework in data visualisation, anchored in the assumption that clarity and visual hygiene are the goal. For a chart in isolation, that holds. But a chart is never read in isolation: it’s read by a person, in a specific context, under specific pressure. Strip a chart down to its cleanest form, and you might be removing the exact layer of context a decision-maker needs. Simplicity isn’t the goal in itself; appropriate complexity is. Data is a message, and the right amount of signal depends entirely on who’s receiving it. “ Which leads to the core principle of data UX: roughly 80% of the work that determines whether a dashboard succeeds happens before you ever draw a chart. That dependency is the thread the rest of this piece pulls on. The 80% That Happens Before The Chart The high-leverage 80% almost never happens on screen. It happens upstream: before a tool is opened, before a dataset is pulled, before a single design choice is made. It comes down to three questions, and once they become habitual, they change what you notice, what you ask, and what you push back on at the outset of every project. - Context: What are we trying to show with this data? This is where you define what the visualisations actually need to serve before you touch any raw data. Writing down the precise operational questions, specifically enough to determine what gets pulled and what gets filtered, is what produces a dashboard that helps with decision-making. - Audience: Who is this for, and how do they think? This is the empathy step. Knowing who’s in the room, what they’re accountable for, and how they engage with data determines how much complexity the visualisation can carry, and how it should be presented. - Insight: What should change once this data lands? A decision, a new direction, a shift in understanding. If the intended strategic outcome isn’t clear during the design phase, it will remain invisible once the dashboard goes live. Context: What Are We Trying To Show With This Data? Most data-heavy projects start backward: teams pull whatever metrics their internal analytics tools already track and build visualisations around them, while the question the data was supposed to answer either gets assumed or never gets asked. This happens simply because we anchor on the data in front of us as the boundary of what’s possible. Defining a goal first sounds obvious, but in practice, it rarely happens with the necessary clarity. “Show me how the product is performing” is not a goal; “Identify which features drive retention among users who signed up in Q1” is, as it includes three things the first doesn’t: a metric, a population, and an implied action. That specificity is what converts an open-ended exploration into a constrained, answerable design problem. Which one you start from determines everything that follows: what you include, what comparisons matter, and what you leave out entirely. Starting with available data produces a dashboard that answers no particular question, because it was never built for one — every number is present, none of them pointed anywhere. Starting with the operational question does the reverse: every element on the screen earns its place, because each one is there to help answer it. For example, consider a UX team trying to fix a leaky checkout flow for an e-commerce website. A data-first approach pulls everything available, from clicks to scroll depth and device types, yielding a massive dashboard that leaves everyone asking, “Okay, but what do we actually change?” A context-first approach starts with a constraint: “At which step of the checkout do users drop off?” By filtering out 90% of the noise, the team builds a simple funnel chart, instantly spots a bottleneck on the payment screen, and knows exactly what to redesign. Audience: Who Is This For, And How Do They Think? Designing for an audience comes down to two things: accountability and familiarity. Familiarity is about data literacy. Do they read charts instinctively, or does a complex visualisation create friction? Handing a dense, multi-layered dashboard to a Head of Sales and a senior analyst is like giving the same map to someone who navigates by landmarks and someone who reads grid coordinates. The data is accurate, but it is only functional for one of them. Accountability dictates how that complexity must be presented. A chart showing a 12% decline carries vastly different weight for the executive responsible for that number versus the analyst simply reporting it. Understanding your audience means grasping this relationship; data is never processed neutrally when your performance is on the line. Together, familiarity and accountability decide one practical thing: how much you can put in front of someone. “ An analyst relies on a high-density environment to conduct diagnostic discovery. By isolating individual behaviour nodes and mapping out raw user flows, they interrogate the data at its atomic level to uncover the hidden insights and underperforming spend that will shape future campaigns. An executive, by contrast, requires a highly synthesised translation of that data to immediately identify what is driving commercial growth. Tailoring a dashboard to your audience means adjusting the density dial, delivering maximum signal with appropriate complexity for the specific brain in the room. Insight: What Should Change Once This Data Lands? Most data projects operate on the comfortable assumption that if a chart is accurate and clear, the insight will take care of itself. In reality, information and insight are entirely different states. Information is what the data shows, whereas insight is the specific decision, shift in understanding, or course correction someone makes as a result of seeing it. If the intended business change isn’t defined before the design begins, a dashboard will default to passive reporting rather than driving action. Marketing and engineering teams experience the danger of this gap whenever a core business metric suddenly plummets. A dashboard built for information simply sounds the alarm, showing a chart that tracks a sharp 15% drop in booking rates. Because the data lacks depth, leadership defaults to panic: they immediately call the UX design team, assuming the app is broken or the checkout flow is flawed. Because the data doesn’t pinpoint the core of the problem, it triggers a costly, misplaced fire drill. A dashboard built for insight isolates the variables required to make an informed decision. Instead of a single, flat booking metric, the visualisation maps the drop against traffic sources and campaign launches — instantly revealing that while app performance and core user conversion are perfectly stable, the sitewide rate was artificially diluted by a massive influx of low-intent click traffic from a newly scaled campaign. The team doesn’t waste time redesigning a functioning app; they get the exact insight needed to pause the underperforming marketing campaign and adjust their acquisition strategy. “ From Questions To Dashboard: A Project Walk-through My aha moment in data visualisation happened during a project for a client-facing B2B SaaS platform focused on enterprise talent management and competency tracking in Pegasystems skills. The platform captured a massive footprint of daily telemetry, and the brief arrived open-ended: “We have an immense archive of user activity, now we need to present it to enterprise teams.” We could very easily have charted everything that was captured, but we wouldn’t be doing end users any favours if they just ended up looking at a data graveyard. My responsibility immediately moved beyond pure interface craftsmanship; it became about architecting a highly practical tool for real people who would open this dashboard routinely and need it to tell them an honest, immediate story about their workflows. Here is how the project actually went. Context The client believed this massive pool of data could help their users perform better, and wanted an interface that finally enabled that growth. Translating that broad ambition into tangible visualisations required defining the practical mechanics of performance. What variables indicate advancement vs passive usage? What does “perform better” actually mean? How do you measure it? An obvious candidate was time spent by product. Every platform tracks it. It is easy to show, and it feels meaningful. But time spent is a proxy; it tells you someone was there, not whether they got anything out of it. The more meaningful signals were competency scores by area, certification completion rates, and historical performance trajectories. Integrating time-spent data alongside these performance metrics added a useful layer of interpretation, helping us surface which modules users were underutilising and whether that directly correlated with lagging scores. Time spent became a supporting signal in the larger story. The second question was about…", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.406, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.406}}
{"format": "sequential_text", "title": "Why Your Website Should Never Stop Changing", "text": "Why Your Website Should Never Stop Changing This article has been kindly supported by our dear friends at Fimo, the infrastructure that keeps a website improving after launch. It runs over your real code, lets your team edit anything visually, and puts agents to work on content, accessibility, and the maintenance you never get to. Incubated at Strapi. Thank you! Every website is at its best the day it ships. The final branch merges, the site goes live exactly as designed, and it is briefly perfect. It will never be this good again. Not because anything breaks. The site keeps working. But the market moves, the messaging shifts, a competitor launches something, and the careful thing you built slowly stops matching the company it represents. A year later, it is a period piece. Not broken, just behind. Every team knows this decay, and almost everyone treats it as a law of nature. It doesn’t have to be that way. A website could keep improving after launch instead of drifting away from its best day, quietly optimizing itself while the team that built it works on something else. Picture it working: while you sleep, an agent catches that last week’s design-system change never propagated to the pricing page, and fixes it. Another finds a set of images shipped uncompressed in a rushed release and optimizes them. A third flags an accessibility regression a new component introduced, and either fixes it or leaves it for you to check. You wake up to a site that is measurably better than the one you left, and a short list of the few decisions the agents wanted your eyes on. That is the version worth wanting. And the moment you take that promise seriously, you run into a problem that has nothing to do with the technology: Almost nobody actually wants a website that changes entirely on its own. Why “Just Make It Autonomous” Is The Wrong Goal The obvious move, once you have capable agents, is to hand them the whole site. Let them write, edit, optimize, and publish, and get out of the way. It sounds like the natural endpoint, and it is the first thing most people picture when they hear “autonomous website.” It is also the thing almost nobody wants once it is real in front of them. We learned this the way you learn most things worth knowing: by building the opposite first. Building Fimo, an autonomous website platform, we set out to make websites fully autonomous, assumed that was the goal, and then watched what people actually did with it. What they did was hesitate. Not because they distrusted the agents, but because a website has no single owner. Different parts belong to different people, and each one wants a different amount of autonomy. So the question was never whether to trust the agents. It was where to draw the line, and for whom. Once you ask it that way, the work splits cleanly into three kinds. Most Of It Is A No-brainer Start with the largest pile, because it is bigger than people expect. Most of what keeps a website healthy is rule-bound, repetitive, and completely joyless. Keeping accessibility compliant as pages change. Propagating a design-system update once a token moves. Catching a broken meta tag, an unoptimized image, a link that rotted when a URL changed three sprints ago. None of this is where anyone’s talent lives. Nobody was hired because of their gift for spotting a missing alt attribute. This is the work you are actively relieved to hand off, and it is the work agents are best at, because it is defined by rules rather than taste. An agent that quietly keeps this layer correct across a whole site, unattended, is not a threat to anyone’s job. It is the tedious eighty percent finally taken care of. Naming how much of the maintenance load actually lives in this pile is what makes the whole idea of an autonomous site feel less like a leap. You are not handing over judgment. You are handing over chores. Some Of It You’d Never Hand Over At the other end sits the work you would not delegate at any price. It is a small pile, but it is the reason you exist. An agent can check a new page against every rule you have given it. It can confirm the contrast passes, the heading order is right, the tokens are correct, the copy matches the style guide. What it cannot do is decide what the page should feel like, or whether the thing you are shipping is, in the taste sense, good. That judgment is exactly what you were hired for, and no amount of capability moves it off your desk. This is the part people reach for first when they resist autonomy, and they are right to protect it. The mistake is thinking the whole site is made of this kind of work. Almost none of it is. But that small part matters more than all the rest, which is why automating everything feels so wrong. And A Lot Of It Depends On Who You Are Between the chores and the untouchable sits the part no product can settle for you, because the line runs through different places for different people. Take one real change: making dark mode the default theme when someone lands on the site. An agent can do it in seconds. The question is who gets to decide it should happen at all. For the designer who owns the site’s identity, the default theme is not a setting; it is a statement about how the brand wants to be seen first, and they want that call. For the developer shipping the change, it is a one-line default with a clear rationale, the kind of thing they would happily let an agent apply and move on. Same change, same site, and the two of them draw the line in opposite places. Notice what is happening there. It isn’t that one of them is cautious and the other reckless. It is that the same task carries different amounts of judgment for each of them. For one person it is a decision; for the other it is a chore. There is no default a product could ship that would be right for both, because “right” is a function of where your value sits, not of the task itself. This is why the control has to be per-task and per-person, and why we stopped trying to find the setting that would work for everyone. There isn’t one. There is only the line each person draws, and the tools to draw it precisely. You Don’t Just Set The Autonomy: You Build The Agent Once you accept that the line is personal, a toggle between “approve” and “delegate” stops being enough. Where the line sits depends on what the agent is actually doing, so the real unit of control is the agent itself. This is where it stopped being a settings problem, and it is the shape Fimo took. You don’t pick from a fixed menu of behaviors. You compose the agents, deciding what each one is even allowed to touch. You can build one from scratch, or take one close to your needs and shape it to your own line: an accessibility agent you trust to run unattended, a content agent you keep close to anything brand-facing. And they don’t stay fixed. They learn from their tasks and from what you teach them, so the boundary you set last month isn’t the one you’re stuck with. What you had to approve then, you can delegate now, not because you lowered your guard but because the agent earned it. The line is not a setting you configure once. It moves as trust is earned, in the direction of less work for you. Start Narrow, and Widen As You Trust It None of this means flipping a site to autonomous on day one. In practice it goes the other way. You delegate a little, watch how it does, and loosen. And you can actually watch. Every agent’s runs, its history, its logs, and a before-and-after of what it changed are there to inspect. Trust doesn’t grow because you got used to the idea; it grows because you can see what happened and compare. The first time an agent quietly fixes something you would have missed, and you can see exactly what it did, the next delegation gets easier. Deadlines keep you from becoming the bottleneck on what you have already handed over. If you don’t weigh in, the agent proceeds. You set the terms once, and you stop being the thing the whole site waits on. The Frozen Site Is The Real Risk The worry people voice first is that an agent will change something on their site without them. Turn it around: the real risk is a site that never changes at all. A frozen site doesn’t stay safe. It just falls behind, slowly, in a way nobody notices until it represents a company that no longer exists. The point of autonomy was never to remove you from your website. It was to remove the decay. “ The point of autonomy is to keep the launch-day version from being the best version, and to let you spend your judgment on the handful of things that actually deserve it, while the rest takes care of itself. Draw the line where your value is. Let the agents hold everything on the other side of it. And let the line move as they prove they can.", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.534, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.534}}
{"format": "sequential_text", "title": "SMIL provides SVG animation without JavaScript", "text": "Timing Charts: A Blueprint For SMIL Animations tags and can fully animate everything in an SVG without JavaScript.We know that everything on the web is a box by default, but you’ll find many animated s pretending to be circles. But if you’ve ever met a real , you’ll know that they’ve got a lot more going for them. Dressed in SVG, they fit into a wider range of crowds than a humble wearing HTML/CSS can. has a strict no .html policy. The tag is not as static as its name suggests. Any embedded JavaScript unfortunately won’t run if you load an SVG file with an tag, but CSS animations work perfectly fine. Many of the SVG attributes do have CSS property counterparts, and the geometry properties have been supported across the major browsers since 2024. Some attributes that you might want to animate, like viewBox , don’t have equivalents yet. Besides JavaScript and CSS, there’s another way to animate SVGs: Synchronized Multimedia Integration Language (SMIL). Despite its quirks, it’s still worth learning. Like CSS animations, SMIL animations also work in tags and can fully animate everything in an SVG, without JavaScript. If you’ve never heard of SMIL or need a refresher, check out Andy Clarke’s well-named article. Then we’ll look at a way to plan an animation and make SMIL markup more manageable. The Break Up SMIL has a problem: it gets bloated quickly. Unlike CSS and JavaScript, where you can list multiple properties in each keyframe and easily reuse animations, each SMIL tag can only target one element and only one property of that element at a time. A property can be animated through a list of values. But it is still one tag, one element, one property. The shortest way you can write a color and opacity change that will run is the following: That’s not bad, but consider that it needs to be repeated for every element included in the animation. A SMIL animation can quickly get longer than its CSS equivalent. To make things easier when starting a new animation, let’s plan all of the elements and properties we want to animate, and create a list of descriptive IDs for each tag. Charting Animation Time And Space I like to plan my animations using what’s called a timing chart. A timing chart is effectively a line segment; some choose horizontal lines, others prefer vertical, which is a great analogy for animation as a whole because line segments can run parallel, overlap, and follow each other with or without a gap. Just like animations. For now, we’re only interested in when animations start and stop. When drawing our charts, we’ll forget about the in-between lines and instead draw a line for each component animation, marking the beginning and end. I like to annotate timing with a circle and a bar. You can draw your chart using whatever, and it doesn’t have to be exactly to scale, as long as the relative timing between all the little animations that make up the whole is clear. Besides, adding labels for the durations is an easy cheat to get around drawing to scale. Here is a demo of how I typically set up a timing chart with more than one animation: The important thing to note is that the timing chart lines are arranged according to how the animations are arranged in time. One piece of the animation follows the next piece, which is followed by a subsequent piece, and so forth. It visualizes how the animation’s parts run together and cascade over time. S(yncbase)MIL A big part of SMIL is synchronization. It’s even in the name, after all. And there are multiple ways to specify when an animation should start (here’s a test case to check what your browser supports). One of the most useful ways is with a syncbase value, which is a SMIL tag’s ID followed by either .begin or .end , with an optional positive or negative offset. Let’s piggyback off the previous animation example that includes changes in color and opacity. If we want the opacity animation to start 300 milliseconds before the color animation finishes, we could do arithmetic. Alternatively, the second animation can use the syncbase value colorChange.end - 300ms . This way, the relative timing between the two animations becomes explicit. Using syncbase values, the beginning of an animation is positioned in time relative to the .begin or .end of some other animation. A positive offset moves the start to the right (forwards in time), and a negative offset to the left (backwards in time). Something with negative offsets is that they can specify a time before the document has loaded or when a click happens. Computers can’t predict the future (at least not yet). The best they can do is jump the animation to where it would have been had the computer peeked into the future to preemptively start the animation. The second animation only runs from start to finish if there is enough room, so to speak. Syncbase values don’t only allow you to connect animations from .end to .begin . Elect a primary animation; the animation that first comes to mind is usually the best representation of the group. All secondary animations can be set with begin=\"primary.begin\" . I’ve only used the ID #primary for emphasis. That way, all the other animations begin relative to that starting point. Stacking animations like this reduces maintenance if, say, we later want the whole group to start at a different time. Let’s put the idea to work and build a loading indicator (or spinner). Then we’re going to explore how changing the relative timing between the parts changes the effect of the whole animation: Step 1: Choose An Image Approach Browsers have wide support for the prefers-reduced-motion media feature and Val Head explains this in depth in another article. We definitely want to respect this user preference as we consider moving things around. In fact, consider it non-negotiable. There are various approaches to adhering to a user’s prefers-reduced-motion setting when it comes to SMIL. Each with its pros and cons. Evaluating early on what’s going to work best for your use case could save you a partial rewrite down the line. For example, we could consider using a element instead of a plain because supports multiple elements that can be used as fallbacks in a media attribute for reduced motion preferences. Or one SVG file with an inline CSS @media query that uses display: none to swap between versions. That said, it’s an approach that might cause trouble in various environments. But browsers are continuously changing, and this might not be an issue in the future. You might also consider a CSS background-image instead because we can wrap that style in a media query — @media (prefers-reduced-motion) — that sets a static image as the fallback for reduced motion preferences. There are even more options we can turn to! For example, SVG’s element can also be used to swap things out for motion preferences. Or, if we prefer everything bundled together, we can use JavaScript .matchMedia() and the handy SMIL DOM interface to control which animations start instead of completely switching out files. For this, I’m avoiding any motion and sticking to opacity animations, which tend to cause less trouble. For a non-interactive animation like this, we can load it in an tag. When we add motion, we can go the route to show the most appropriate version of our animation. Step 2: Draw The Graphics We’re going to do our own version of the classic three-dot spinner: SVG wizards might be able to do everything directly in a text editor. I recommend using a graphic editor like Inkscape if you’re having trouble visualizing how the markup will be rendered. Once again, Andy Clarke has a great article about his process for optimizing and structuring his own drawings. Note: There’s a gotcha with Inkscape. Setting what you would expect to be an element’s ID via the Layers window actually sets the value of a metadata attribute used internally by Inkscape. Use Inkscape’s object properties or XML editor window to set the true element’s ID. Your mileage may vary with a different editor. Also, in Inkscape, remember to save the file as optimized SVG when the drawing is done to strip away unneeded metadata. Step 3: Outline The Animation OK, so we’re sticking with the opacity animation idea. The dots are going to fade in and out. We’ll use separate tags for those. Six tags in total. Our naming scheme is going to be straightforward: we’ll call them #fadeIn and #fadeOut , and to differentiate between each pair of tags, we’ll postfix the tag’s ID with either Left , Middle or Right . Try to follow a convention that makes sense to you when coming up with your own IDs. The fade-in tag for the dot on the left: And the fade-out for the middle dot: Step 4: Time The Animations We have an infinite number of ways in which we could space these six animations in time. Let’s look at a couple of choice examples alongside their timing charts to see how changing the arrangement of the parts impacts the visual effect of the whole animation. To narrow our choices a bit, all of the tags will use the same dur value, and none of the syncbase values will have offsets. For someone coming from a culture that reads from left to right, the dots appearing on screen along the same pattern would feel natural. Let’s also start with all the dots fading out together at the end: Syncbase values stagger the fade-ins and restart the loop when the dots have disappeared: Since all the fade-outs end at the same time, it is an arbitrary choice which one we use to restart the loop. We’ll consider #fadeOutLeft as the primary animation here and also synchronize the other fade-outs to it with the syncbase value fadeOutLeft.begin . Later, if we want to move the fade-outs in time, all we do is change when #fadeOutLeft starts. Some Alternate Timings Instead of a group fade-out, we could stagger them just like the fade-ins: Without adding an offset, there are a couple of points in time we could start #fadeOutLeft at. If it starts on fadeInRight.end : The visual effect is subtly changed by moving up a spot and starting #fadeOutLeft on fadeInMiddle.end instead: We can see from the charts that we could try moving up a spot further to fadeInLeft.end : How about starting the sequence with a fade-out: You might prefer to start with the dot in the middle: As you iterate on your animation, timing charts are a great way to keep track of your work, and they make visual comparison between versions possible. And by drawing a timing chart, you might even see a pattern in the timing between the parts of the animations that you might otherwise have missed. Step 5: Adding More Animations As you animate more elements and properties, it gets harder to keep track of what starts when. To see how timing charts can help you make sense of things, let’s build on the basic spinner: I’ve added a for each dot to the drawing. We’ll move those into to a tag and remove the fill=\"white\" . As the animation runs, the rectangles are going to move over the dots for a different approach to animating the stroke than by animating stroke-dashoffset . We only need a single for all three dots, but it adds structure to the document, and it’s good practice to wrap it, and similar tags, in a tag: Remember to set the clip path for the s. Either with CSS or using the clip-path attribute: Because the dots now have a stroke added, to leave their size unchanged, we need to compensate by subtracting half the value of stroke-width from r : That’s all the changes the graphics need. Have a look at the animated version with its timing chart, then we’ll look in more detail at the changes that have been made to the animation: There’s a new animation, #moveClipPathLeft , that starts the whole sequence, and to tweak the animation’s rhythm a bit, there’s a 1s delay between when the fade-outs end and the loop restarts: You could use s to move the rectangles instead, but we need…", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.397, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.397}}
{"format": "sequential_text", "title": "New EU Guidelines For AI Labelling", "text": "New EU Guidelines For AI Labelling There’s been a lot of confusion and panic this week about “huge fines”, “drastic measures” and “sweeping new AI rules” in the EU. In reality, it’s a lot more narrow — and a lot more sensible. And mostly it’s about making AI more obvious when it actually needs to be obvious — especially for AI-generated content. Starting from Aug 2, 2026, AI labelling is a legal requirement for any company that serves EU citizens. And similar to European Accessibility Act, it’s not limited to EU companies. It affects any company worldwide with EU operations as long as their AI output is used by people in the EU. Let’s see what exactly it means for us. What Actually Needs Labelling The goal of AI labelling is to help everyone exposed to AI content to recognize, in a clear and distinguishable way, that the content has been artificially generated or manipulated. According to Article 50(4) of the AI Act, AI labelling applies to: - Deepfakes. Any image, audio, or video that resembles a real person, object, place, or event and would falsely appear authentic or truthful. Content that is not deceptively realistic generally doesn’t apply. - Chatbots and AI agents. Users must be informed if they’re not talking to a human. - Fully AI-written text. Specifically on matters of public interest, where there has been no human review or editorial work. - Emotion recognition and biometric categorization tools. Both providers (who build or supply the AI system) and deployers (who use it) carry legal obligations. Similar to GDPR and EAA, a company doesn’t escape Article 50 just because it licensed an external AI tool from a third party. However, it doesn’t mean that all AI-generated content must be explicitly labelled. Not All AI-Generated Content Must Be Labelled Beyond the use cases above, pretty much everything else — the vast majority of AI-assisted work — simply isn’t covered by new transparency rules. Most notably, the disclosure obligation does not apply where the AI-generated text has been reviewed and edited by a human, with a named person or entity taking editorial responsibility for it. Some confusion circles around what exactly “public interest” means, where it starts and where it ends. On its own, it refers to health, safety, environment, economy, finances, politics, science, or culture. If AI-generated product claims touch upon them, the disclosure rule applies. Some law firms recommend labelling realistic AI-generated illustrations or photos as a precaution for advertising, marketing and other commercial content. AI-generated product illustrations, photos, or posters do need a disclosure, as long as they resemble a real person, place, object, or event. The Fine Line Between “Edited” And “AI-Generated” But at which point does edited AI content stop being AI content? When a form is pre-filled with AI, but then a user edits it, is it still AI? EU Commission’s guidance is a little fuzzy. Small assistive edits — spellcheck, grammar, formatting, cropping, colour correction, and AI-generated translation — don’t count as AI generation. AI-generated summaries, composite imagery, substantive rewrites, or adding and removing elements from a photo are considered AI generation. In practice, fine-tuning a sentence a person wrote is fine, but generating the sentence on its own requires a disclosure. “A human skimmed it before publishing” doesn’t qualify as editorial review. The Commission is explicit that it needs to be substantive, with a named person responsible for the editorial control. In other words, the fine line lies between intentional manual intervention and automated generation. The latter always has to be disclosed (exception: closed B2B environments). AI Sparkles Probably Not Enough As part of the Code of Practice, the European Commission has published an EU AI icon set. It’s a specific “AI” mark (similar to the AI label in Carbon Design System) — not the generic ✨ sparkle that many products use to signal AI. The signal must be “clear and distinguishable”. The sparkle might be too ambiguous to signal AI clearly. Mostly because it’s often used to mean “AI-powered feature”, rather than “this specific content was generated by AI”. That’s the kind of signal EU guidelines are trying to rule out. The Commission is explicit: using an icon “does not establish legal compliance by itself.” A barely visible icon, a note buried in the footer, or a label that flashes for a second are all not compliant. The icon should be clearly visible, with a plain language label and accessible to assistive technologies. A safe bet is to pair any icon with plain text (“AI-generated”) — and it needs to persist when being reshared or downloaded. In fact, the EU Commission also published Code of Practice on marking and labelling of AI content. It Isn’t Just EU It might feel like a yet another regulation coming from the EU, but in reality there are plenty of other similar regulations that emerged recently worldwide: - China has mandatory AI labelling since 1 September 2025. With visible tags and watermarked metadata. - California has SB 942, as amended by AB 853, which became mandatory on the exact same day as the EU rules (2 August 2026), deliberately timed to align. - South Korea has the AI Basic Act that took effect on 22 January 2026, widely cited as the first comprehensive national-level AI law to mandate deepfake labels. Fines are modest by EU standards (roughly $20K per violation), with a one-year grace period before enforcement bites. - India has an IT Rules amendment, in force since 20 February 2026. Platforms must label “synthetically generated information”, and takedown timing for most harmful deepfakes was cut to 3 hours. All of these are signs of upcoming AI regulation that looks more like a pattern, rather than a coincidence. So if you’re shipping anything AI this year, it’s probably a good idea to have a conversation about what exactly is going to be AI-labelled, and what not. Wrapping Up One final note is that new EU AI transparency rules are much broader than US laws on AI disclosure, where certain state laws require disclosures for synthetic human performers, political advertising or specific AI applications. None of this really deserves panic or confusion. It’s about a fairly simple idea that has been emerging worldwide at almost the same time: When AI content could easily be mistaken for human content, creators must say so — in a way that is clear, obvious, and unambiguous. And parts of the UI that are AI-generated must be disclosed as such. If anything, it will help people distinguish between AI slop and not AI — and everybody can only benefit from that. Meet “Design Patterns For AI Interfaces” Meet Design Patterns For AI Interfaces, Vitaly’s new video course with practical examples from real-life products — with a live UX training happening soon. Jump to a free preview. Video + UX Training $ 450.00 $ 799.00 Get Video + UX Training30 video lessons (10h) + Live UX Training. 100 days money-back-guarantee. Video only 30 video lessons (10h). Updated yearly. Also available as a UX Bundle with 3 video courses. Useful Resources - Safer and more transparent AI, European Commission’s official announcement - EU Icons for labelling AI-generated content, the actual icon set and placement rules - Guidelines on transparency obligations (Article 50), the detailed compliance guidance - Code of Practice on marking and labelling of AI-generated content - FAQ: Transparency obligations under Article 50, plain-language Q&A - The Problem With AI Sparkle Icons, why ✨ is too ambiguous as a disclosure signal (Nielsen Norman Group) - Carbon Design System: AI Label, a production-ready pattern for clear, accessible AI disclosure", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.4, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.4}}
{"format": "sequential_text", "title": "Building Tactile UX: Honoring Intentional Design With Lottie", "text": "Building Tactile UX: Honoring Intentional Design With Lottie This article has been kindly supported by our dear friends at Isadora Agency who help enterprise brands and market leaders navigate digital, evolve profitably, and launch unforgettable websites, products, and campaigns. Thank you! When front-end developers and UX engineers are tasked with building a web interface that feels tactile, bouncy, or destructive, the industry instinct is almost always the same: reach for a physics engine. Frameworks like Matter.js, Cannon.js, or custom WebGL solutions have become the gold standard for creating immersive, gamified websites. When our team at Isadora Agency set out to build Stress Release, a digital stress-relief squeeze toy designed to let burnt-out creatives smash, stretch, and distort animated UI characters, we initially explored that route. The goal was to build a highly tactile experience where every click yielded a satisfying, squishy reaction. But as we began prototyping, we realized something crucial: Physics engines produce plausible motion, but in our case, the animators produced intentional motion. We didn’t need our characters to act like realistic rubber balls bouncing uncontrollably around a canvas. We needed them to react in very specific, highly designed ways. So, we scrapped the physics engine entirely. In this article, we’ll break down how we built a real-time stress-relief squeeze toy without a single line of WebGL or Matter.js, relying entirely on programmatic Lottie state controls, DOM manipulation, and distance-based math. The Design Requirements: Intentional Motion Our core requirement for Stress Release was absolute deterministic control. Our animators had crafted bespoke .json Lottie files that required exact, frame-by-frame sequencing. For instance, our ‘mega squeeze’ reaction required a precise 181-frame build-up followed by a specific release sequence. To honor this design, we needed an architecture that wouldn’t overwrite the animators’ crafted keyframes with algorithmic approximations. The tighter the click-feedback loop (click → squish → score), the more you need deterministic frame control. By choosing programmatic state control using Lottie’s native API, we ensured that the interaction layer acted as a flawless trigger for the animation layer. Creating Tactile Feedback: Mapping DOM Elements To Lottie States Because our architecture relied on Lottie and the standard DOM, rendering is handled directly by the Lottie runtime, which plays the JSON-based vector animations as SVGs internally. We selected elements directly by ID and CSS class, driving their behavior using a combination of Lottie animation segments, CSS transforms, and click-event math. To achieve a deeply satisfying “tactile feel” upon hitting a character, we used radial input mapping. The first step was converting the click from page coordinates into the character’s local coordinate space. Every click was measured against the character’s center point, then translated into score, feedback intensity, and explosion placement: // Character's center point in its own coordinate space var x_center = parseFloat($(\"#playChar\").width() / 2); var y_center = parseFloat($(\"#playChar\").height() / 2); // Click position relative to the character's top-left corner var offset = $(\"#playChar\").offset(); // document-relative position var X = parseFloat(e.pageX - offset.left); var Y = parseFloat(e.pageY - offset.top); // Vector from center to click point var a = parseFloat(X - x_center); var b = parseFloat(Y - y_center); Then we calculate the straight-line distance from the center of the click using the Pythagorean theorem: var distance = Math.hypot(a, b); That single number drives everything: the score, the feedback intensity, and where the explosion animation appears: // Distance zones map to point rewards if (distance < 10) givePts = 100; // bullseye else if (distance < 40) givePts = getRndInteger(70, 90); else if (distance < 70) givePts = getRndInteger(40, 70); else if (distance < 100) givePts = getRndInteger(20, 40); else if (distance < 120) givePts = getRndInteger(10, 20); else if (distance < 145) givePts = getRndInteger(1, 10); else givePts = 0; // miss // Explosion Lottie repositioned to the exact click point var shiftPosition = window.innerWidth < 1023 ? -20 : 200; $(\"#explosionChar\").css({ \"margin-left\": a + shiftPosition + \"px\", \"margin-top\": b + shiftPosition + \"px\", }); // Fire the squish animation instantly explosion.goToAndPlay(0); The result is a concentric zone system — a perfect circle of scoring rings around the character’s center, similar to a dartboard. The visual complexity of the Lottie SVG is completely irrelevant to hit detection; the hitbox is always a clean circle. Critically, the explosion Lottie animation is repositioned to (a, b) — the same vector used for scoring, so it always appears exactly where the player clicked. This spatial accuracy creates the tactile “I hit that” sensation entirely through math and DOM positioning. Interaction Handling: Controlling The Narrative Because the experience used DOM-managed SVG elements, desktop clicks and mobile taps could be handled directly through native event listeners. This avoided extra raycasting or coordinate remapping layers, while keeping the interaction model aligned with how the animations were rendered. Since the game requires a visual reaction at a specific point, Lottie handles all the squish and bounce feelings internally through its animation curves. Each character has a defined set of animation sections (idle loops, reaction frames, and end states) stored as frame ranges. When a click lands, we jump directly to the exact segment that matches the current game state: // Animation sections defined as frame ranges per character const play_segments = [{ charId: 0, sections: { idle: [0, 40], // looping idle state squeeze1: [41, 80], // light reaction squeeze2: [81, 120], // medium reaction squeeze3: [121, 160], // heavy reaction }, playOrder: [\"squeeze1\", \"squeeze2\", \"squeeze3\"], endAnimation: [161, 200] }]; On every click, we advance through the play order and fire the next segment: function stepAnim() { let p = play_segments[0]; let i = p[\"playOrder\"][curr_order_play]; let playNow = p[\"sections\"][i]; playChar.stop(); // halt current segment immediately playChar.loop = false; // no looping - play once and stop playChar.playSegments(playNow, true); // jump to exact frames, force immediately curr_order_play++; canPlayAnim = 0; // lock out further clicks mid-animation if (curr_order_play > p[\"playOrder\"].length - 1) { curr_order_play = 0; // cycle back to start of sequence } } When the segment completes, control returns to the idle loop: playChar.onComplete = function() { canPlayAnim = 1; // unlock clicks again if (!playEnd) playIdleState(); }; function playIdleState() { playChar.playSegments([0, 40], true); // return to idle loop playChar.loop = true; } And for the mega squeeze build-up, the bar loops on a specific frame range until triggered: // Loop the \"ready to release\" frames until player activates indikL.loop = true; indikL.playSegments([181, 302], true); // On activation - play the release sequence once indikL.loop = false; indikL.playSegments([96, 396], true); indikL.goToAndStop(0, true); // hard reset after completion The Responsive Benefit Of DOM Elements Another major factor in our architectural decision was responsive behavior. Because we built Stress Release in the DOM, we bypassed the complexities of scaling bounding boxes and collision vectors across different devices. We handled responsive resizing entirely through CSS variables. By recalculating CSS custom properties on every resize, the layout simply reacts to the updated variables, and the Lottie SVGs scale naturally inside their containers without losing their state: const appHeight = () => { const doc = document.documentElement; doc.style.setProperty(\"--doc-height\", ${window.innerHeight}px); doc.style.setProperty(\"--doc-width\", ${doc.clientWidth}px); }; window.addEventListener(\"resize\", appHeight); appHeight(); // run immediately on init Mobile Performance Optimization: The Cost Of Lottie While this architecture gave us total control over the art direction, it introduced a different challenge: file size. Lottie JSON files can be heavy. We had 21 different character animations, plus multiple explosion variants that all needed to load. To ensure the experience remained fluid — especially on mobile devices — we implemented a few aggressive optimization strategies: - Connection monitoring We tracked initial asset load time usingperformance.now() to detect slow connections and flag when load times exceeded 5 seconds. - Sequential asset loading Rather than initialising all 21 character animations simultaneously, we load them in pairs using await, advancing only when each pair completes. This prevents a burst of simultaneous network requests and render work from blocking the browser on low-end devices. - Aggressive memory management Instead of keeping our heavy explosion animations in memory, we destroy and recreate them on the fly. This trades a tiny instantiation cost for a much lower idle memory footprint. - Dynamic quality reduction Quality reduction is a single API call applied immediately after each shelf character loads. The key is applying different quality levels depending on the character’s role in the scene: // Shelf screen - 21 animations playing simultaneously shelf = lottie.loadAnimation({ container: document.getElementById(\"charShelf\" + i), renderer: \"svg\", loop: true, autoplay: true, path: \"assets/shelf/\" + shelfFolders[i] + \"/\" + shelfFolders[i] + \".json\", }); lottie.setQuality(0.5); // 50% quality - reduces interpolation calculations shelf.setSpeed(0.6); // 60% speed - fewer frame calculations per second // Play screen - single focused character playChar = lottie.loadAnimation({ container: document.getElementById(\"playChar\"), renderer: \"svg\", loop: true, autoplay: true, path: chosenChar.url, }); lottie.setQuality(1); // full quality - only one animation at a time Conclusion: Choosing The Right Tech For The Design When determining the stack for a gamified web experience, it is critical to let the design requirements dictate the technology. Because our interactions required bespoke, highly controlled visual reactions, we opted for programmatic state control over emergent simulation. This decision empowered the animators to dictate the exact feel of the experience, leaving the code to do what it does best: listen, calculate, and trigger. “ Further Resources Want to try implementing this yourself, or see exactly how it feels in the browser? Check out these resources: - Play with the code. We have prepared a simplified demo example on CodePen demonstrating a character reacting to a click usingplaySegments() . - See the final product. Check out the live Stress Release site to see all 21 characters and the optimization strategies in action. - Read the docs. Explore the official Lottie Web documentation to learn more about the player controls we utilized. Specifically, exploreloadAnimation() ,playSegments() ,setSpeed() , andsetQuality() — the four methods that power the entire interaction layer described in this article.", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.401, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.401}}
{"format": "sequential_text", "title": "How Baseline Can Help You Ship Less JavaScript", "text": "How Baseline Can Help You Ship Less JavaScript Most of us install a dependency once and never look at it again. It does its job, the tests pass, and we move on. But the web platform keeps moving too, and a surprising number of the libraries sitting in your package.json today are now built into the browser. In a typical mid-sized JavaScript app, you can often find somewhere between 60KB and 90KB (minified and gzipped) of dependencies that the platform can now handle on its own. Date and number formatting, HTTP requests, modals, tooltips, deep cloning, grouping arrays: these were all real gaps a few years ago. A lot of them aren’t gaps anymore. The reason those libraries stick around isn’t laziness. It’s that most teams don’t re-audit their dependencies on a Baseline cadence, or are simply not aware of how fast browsers are shipping these days. You check npm audit for security, but is this library still doing something the browser can’t? is a question that rarely gets asked. So the libraries stay. In this article, we’ll run that audit together. Instead of going through dependencies one by one, we’ll work in clusters, because the wins tend to come in groups. We’ll do the bundle math, build a small decision framework you can reuse, and stay honest about the cases where the platform still falls short. By the end, you’ll have a repeatable process you can run on your own package.json . What “Baseline” Actually Means Before we start deleting things, let’s quickly recap what Baseline is. Feel free to skip this section if you’re already familiar. Baseline is a project from the WebDX Community Group that tells you, in plain terms, how safe a web feature is to use across the major browsers (Chrome, Edge, Firefox, and Safari). A feature can be in one of three states: - Limited availability The feature hasn’t shipped in all the major engines yet. Not safe to rely on without a fallback. - Baseline Newly available The feature has just landed in all the major engines. It works for users on up-to-date browsers, but older devices in the wild may not have it yet. - Baseline Widely available The feature has been in all the major engines for 30 months. At this point, you can reach for it without much thought. That 30-month gap between “Newly” and “Widely” matters a lot for this audit. A feature that’s Widely available is something you can usually drop a library for today. A feature that’s only Newly available is something you can drop a library for if you check your audience first, or if you’re comfortable with a small feature check. We’ll treat those two cases differently throughout. You can look any feature up on webstatus.dev, on MDN (every reference page shows a Baseline badge near the top), or programmatically with the web-features npm package. We’ll use all three later when we run the audit on a real project. A Decision Framework Before You Delete Anything It’s tempting to read “the browser does this now” and start ripping libraries out. Let’s not do that. A swap that looks free on paper can quietly break things for a chunk of your users, or cost you a feature you were relying on without realizing it. So before dropping any library, ask three questions. We’ll reuse these in every cluster below. 1. Is the replacement Baseline-safe for my audience? Not “is it Baseline” in the abstract, but “is it safe for the people who actually use my app.” If the native feature is Widely available, this is usually a yes. If it’s only Newly available, check your analytics or your browserslist config and see what share of your users would miss out. A B2B dashboard where everyone’s on the latest browser is a very different situation from a public-facing site with a long tail of old Android devices. 2. What does the swap actually cost? Dropping a library isn’t always free. Sometimes the native feature isn’t supported widely enough yet, so you’d reach for a polyfill. If that polyfill is heavier than the library you’re removing, you’ve made your bundle bigger, unless you load it conditionally. We’ll see exactly this with Temporal later. 3. Does the platform feature cover my real use case? Libraries often do more than the platform feature they resemble. axios isn’t just fetch with automatic JSON parsing; it has interceptors, request cancellation, and retries. If you’re using those, a straight swap to fetch will leave you reimplementing them. Check what you actually use before assuming it’s a drop-in replacement. Keep these three in mind. Every cluster below is really just these questions applied to a different corner of your dependencies. Cluster 1: Internationalization (The Biggest Drop Today Win) This is the cluster where you’ll usually find the most KBs sitting on top of features that are already Widely available. The browser ships a whole family of formatting tools under the Intl namespace, and a lot of small, popular libraries became unnecessary. Here are the usual suspects and what replaces them: timeago.js (1 KB gz) →Intl.RelativeTimeFormat pluralize (2.3 KB gz) →Intl.PluralRules numeral (3.9 KB gz) →Intl.NumberFormat humanize-duration (6.6 KB gz) →Intl.DurationFormat - list-joining helpers → Intl.ListFormat Let’s walk through some of them. Relative Time timeago.js exists to turn a timestamp into “3 hours ago”. Intl.RelativeTimeFormat does the same thing, and it’s Baseline Widely available. const rtf = new Intl.RelativeTimeFormat(\"en\", { numeric: \"auto\" }); rtf.format(-1, \"day\"); // \"yesterday\" rtf.format(3, \"hour\"); // \"in 3 hours\" rtf.format(-2, \"week\"); // \"2 weeks ago\" The numeric: \"auto\" option is the nice touch here: it gives you “yesterday” instead of “1 day ago” where the language has a word for it. You pass a number and a unit, and you get a localized string back. You may be wondering about the one thing timeago.js does that this snippet doesn’t: it picks the unit for you. Given a date, timeago.js decides whether to say “seconds” or “days.” Intl.RelativeTimeFormat expects you to do that part. It’s a few lines of arithmetic (work out the difference, find the largest unit that fits), and once you’ve written that helper, you don’t need the library anymore. Numbers, Currency, And Lists Intl.NumberFormat covers most of what number-formatting libraries do: thousands separators, currency, percentages, and compact notation. new Intl.NumberFormat(\"en-US\").format(1234567.89); // \"1,234,567.89\" new Intl.NumberFormat(\"en-US\", { style: \"currency\", currency: \"USD\" }).format( 1234.5, ); // \"$1,234.50\" new Intl.NumberFormat(\"en\", { notation: \"compact\" }).format(1200000); // \"1.2M\" And Intl.ListFormat , Widely available, handles the “join an array into a sentence” problem, including the Oxford comma, which is the kind of thing people write fiddly helper functions for: const lf = new Intl.ListFormat(\"en\", { style: \"long\", type: \"conjunction\" }); lf.format([\"Alice\", \"Bob\", \"Carol\"]); // \"Alice, Bob, and Carol\" The One Caveat: Durations humanize-duration turns a number of milliseconds into “1 hour, 30 minutes”. The platform equivalent is Intl.DurationFormat : const df = new Intl.DurationFormat(\"en\", { style: \"long\" }); df.format({ hours: 1, minutes: 30 }); // \"1 hour, 30 minutes\" One thing to keep in mind is that Intl.DurationFormat is Baseline Newly available at the time of writing, not Widely available. It landed in all the major engines in March 2025, and it’s on track to become Widely available in 2027. So this one fails question 1 for broad-audience apps unless you check your traffic first or add a fallback. For an internal tool on modern browsers, it’s fine today. For a public site with old devices, give it another year or guard it with a feature check. The Math On This Cluster If your app uses the full set (humanize-duration , timeago.js , pluralize , numeral ), that’s roughly 14 KB gzipped of dependencies, most of it replaceable right now with Widely available APIs. The internationalization cluster is usually the easiest win in the whole audit. Cluster 2: HTTP Clients This cluster is more nuanced, so it’s a good one to slow down on. The browser HTTP libraries people reach for are axios (17 KB gz) and superagent (19 KB gz). For most requests, fetch plus AbortController covers what you need, and both are Widely available. A basic GET looks like this: // axios const { data } = await axios.get(\"/api/users\"); // fetch const res = await fetch(\"/api/users\"); const data = await res.json(); The one extra line (res.json() ) is fetch being explicit where axios was implicit. That’s the pattern across this whole cluster: fetch does less for you by default, and you decide whether you want the things it leaves out. Timeouts axios has a timeout option. fetch has AbortSignal.timeout() : const res = await fetch(\"/api/users\", { signal: AbortSignal.timeout(5000), // abort after 5 seconds }); Where fetch Doesn’t Replace axios This is where question 3 does most of the work, so let’s be specific about the gaps: fetch doesn’t reject on HTTP errors. A404 or500 is a resolved promise, not a rejection. You have to checkres.ok yourself.axios rejects on any non-2xx status.- No interceptors. If you rely onaxios interceptors to attach auth tokens or handle 401s in one place,fetch has no equivalent. You’d wrapfetch in your own function or class to get the same behavior. - No automatic retries. axios (with a plugin) can retry failed requests. Withfetch , that’s your code to write. - No upload progress. fetch still can’t report upload progress in a first-class way. If you have a file uploader with a progress bar, that’s a real reason to keep a library. I personally heavily rely on interceptors in my interactive online courses, such as Learn JavaScript, and I have solved that for years using a custom class on top of fetch . I’ve shipped this to millions of users and have seen lots of success with it. None of these are hard to rebuild, and most apps only use one or two of them. But this is exactly the kind of cluster where you shouldn’t do a blind find-and-replace. Look at how you actually use your HTTP client first. If it’s plain GETs and POSTs, dropping axios for a thin fetch wrapper saves you about 17 KB gzipped. Cluster 3: UI Primitives This cluster has some of the most satisfying swaps, because the platform features don’t just match the libraries, they’re often more accessible than what teams ship by hand. The libraries here are modal dialogs (something like a11y-dialog , 1.8 KB gz), tooltip and popover libraries (tippy.js , 14 KB gz, which bundles Popper for positioning), focus-trap (6.6 KB gz), and body-scroll-lock (1.3 KB gz). They get replaced by three platform features: the element, the Popover API, and CSS anchor positioning. The Element A huge amount of modal-related code exists to solve accessibility problems: trapping focus inside the modal, closing on Escape , restoring focus to the previous element when the dialog is closed, and rendering above everything else. The element, Widely available, does all of that for you. Delete this file? Cancel Delete const dialog = document.querySelector(\"#confirm\"); dialog.showModal(); // focus moves in, background goes inert, Escape closes it dialog.addEventListener(\"close\", () => { console.log(dialog.returnValue); // \"cancel\" or \"delete\" }); Calling showModal() does the work that focus-trap was installed for: focus moves into the dialog, the rest of the page becomes inert so you can’t tab out of it, Escape closes it, and focus returns to the element that opened it. The dialog renders in the browser’s Top layer, so you don’t fight z-index . You also get a ::backdrop pseudo-element to style the overlay. That single element can replace your modal library and focus-trap . The one piece it doesn’t handle on its own is locking the background from scrolling, which is what body-scroll-lock was for. That’s now one line of CSS: body:has(dialog:modal) { overflow: hidden; } If you’re wondering why we’re using dialog:modal instead of dialog[open] , it’s because the open attribute is set as soon as you…", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.395, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.395}}
{"format": "sequential_text", "title": "Small Joys And Big Adventures (August 2026 Wallpapers…", "text": "Small Joys And Big Adventures (August 2026 Wallpapers Edition) Everybody loves a beautiful wallpaper to freshen up their desktops and home screens, right? To provide you with inspiring designs on a regular basis, we started our monthly wallpapers series more than 15 years ago, and from the very beginning to today, artists and designers from across the globe have tickled their creativity and contributed their artworks to it. This August is no exception, of course, so following our monthly tradition, we have a new collection of wallpapers waiting for you below. Created with love by the community for the community, all of them come in a variety of screen resolutions and can be downloaded for free. A huge thank-you to everyone who shared their wallpapers with us this time around — this post wouldn’t be possible without your kind support! If you would also like to be featured in one of our upcoming wallpapers posts, please don’t hesitate to submit your design. We can’t wait to see what you come up with! Happy August! - You can click on every image to see a larger preview. - We respect and carefully consider the ideas and motivation behind each and every artist’s work. This is why we give all artists the full freedom to explore their creativity and express emotions and experience through their works. This is also why the themes of the wallpapers weren’t anyhow influenced by us but rather designed from scratch by the artists themselves. Fishionista Designed by Ricardo Gimenes from Spain. - preview - with calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 The Sacred Code Of The Three “Before complex treaties and endless debates, humanity forged a simpler pact. A timeless triangle of absolute balance. The Immutable Stone, unyielding in its silence. The Gentle Parchment, quiet yet capable of boundlessness. The Sharp Blade, precise and forever restless. None holds absolute power; each surrenders to another in an eternal, perfect loop. On World Rock Paper Scissors Day, we honor the swift wisdom of three simple gestures that can break any deadlock and remind us that every force has its match. Fist, palm, or shears — what is your first move?” — Designed by PopArt Studio from Novi Sad, Serbia. - preview - with calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 August Summer Hours Designed by Ricardo Gimenes from Spain. - preview - with calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 Among the Stars “August is one of the best months for stargazing, with clear nights and plenty of meteor activity. Some nights bring shooting stars, while others reveal constellations that are easy to miss during the rest of the year.” — Designed by Ginger IT Solutions from Serbia. - preview - with calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Happiness Happens In August “Many people find August one of the happiest months of the year because of holidays. You can spend days sunbathing, swimming, birdwatching, listening to their joyful chirping, and indulging in sheer summer bliss. August 8th is also known as the Happiness Happens Day, so make it worthwhile.” — Designed by PopArt Studio from Serbia. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Summer Day Designed by Kasturi Palmal from India. - preview - without calendar: 800x600, 1280x1024, 1600x1200, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Bee Happy! “August means that fall is just around the corner, so I designed this wallpaper to remind everyone to ‘bee happy’ even though summer is almost over. Sweeter things are ahead!” — Designed by Emily Haines from the United States. - preview - without calendar: 640x480, 800x600, 1280x720, 1280x800, 1280x960, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Retro Road Trip “As the sun dips below the horizon, casting a warm glow upon the open road, the retro van finds a resting place for the night. A campsite bathed in moonlight or a cozy motel straight from a postcard become havens where weary travelers can rest, rejuvenate, and prepare for the adventures that await with the dawn of a new day.” — Designed by PopArt Studio from Serbia. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Spooky Campfire Stories Designed by Ricardo Gimenes from Spain. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 Oh La La… Paris’ Night “I like the Paris night! All is very bright!” — Designed by Verónica Valenzuela from Spain. - preview - without calendar: 800x480, 1024x768, 1152x864, 1280x800, 1280x960, 1440x900, 1680x1200, 1920x1080, 2560x1440 Relax In Bora Bora “As we have taken a liking to diving through the coral reefs, we’ll also spend August diving and took the leap to Bora Bora. There we enjoy the sea and nature and above all, we rest to gain strength for the new course that is to come.” — Designed by Veronica Valenzuela from Spain. - preview - without calendar: 640x480, 800x480, 1024x768, 1280x720, 1280x800, 1440x900, 1600x1200, 1920x1080, 1920x1440, 2560x1440 Cowabunga Designed by Ricardo Gimenes from Spain. - preview - without calendar: 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 Summer Nap Designed by Dorvan Davoudi from Canada. - preview - without calendar: 800x480, 800x600, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Coffee Break Time Designed by Ricardo Gimenes from Spain. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Psst, It’s Camping Time… “August is one of my favorite months, when the nights are long and deep and crackling fire makes you think of many things at once and nothing at all at the same time. It’s about heat and cold which allow you to touch the eternity for a few moments.” — Designed by Igor Izhik from Canada. - preview - without calendar: 1024x768, 1024x1024, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Work Hard, Play Hard “It seems the feeling of summer breaks we had back in school never leaves us. The mere thought of alarm clocks feels wrong in the summer, especially if you’ve recently come back from a trip to the seaside. So, we try to do our best during working hours and then compensate with fun activities and plenty of rest. Cheers!” — Designed by ActiveCollab from the United States. - preview - without calendar: 1080x1920, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1920x1080, 1920x1200, 1920x1440, 2560x1440, 3840x2160 Searching For Higgs Boson Designed by Vlad Gerasimov from Georgia. - preview - without calendar: 800x600, 960x600, 1024x768, 1152x864, 1229x768, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1440x900, 1440x960, 1600x1200, 1600x1200, 1680x1050, 1728x1080, 1920x1200, 1920x1440, 2304x1440, 2560x1600 Subtle August Chamomiles “Our designers wanted to create something summery, but not very colorful, something more subtle. The first thing that came to mind was chamomile because there are a lot of them in Ukraine and their smell is associated with a summer field.” — Designed by MasterBundles from Ukraine. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1366x768, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Shrimp Party “A nice summer shrimp party!” — Designed by Pedro Rolo from Portugal. Handwritten August “I love typography handwritten style.” — Designed by Chalermkiat Oncharoen from Thailand. - preview - without calendar: 320x480, 640x480, 800x480, 800x600, 1024x768, 1024x1024, 1152x864, 1280x720, 1280x800, 1280x960, 1280x1024, 1400x1050, 1440x900, 1600x1200, 1680x1050, 1680x1200, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Childhood Memories Designed by Francesco Paratici from Australia. - preview - without calendar: 320x480, 1024x768, 1024x1024, 1280x800, 1280x1024, 1366x768, 1440x900, 1680x1050, 1920x1080, 1920x1200, 2560x1440 About Everything “I know what you’ll do this August. Because August is about holiday. It’s about exploring, hiking, biking, swimming, partying, feeling, and laughing. August is about making awesome memories and enjoying the summer. August is about everything. An amazing August to all of you!” — Designed by Ioana Bitin from Bucharest, Romania. - preview - without calendar: 320x480, 800x480, 800x600, 1024x768, 1280x960, 1280x1024, 1440x900, 1600x1200, 1680x1050, 1920x1080, 1920x1200, 1920x1440, 2560x1440 Launch “The warm, clear summer nights make me notice the stars more — that’s what inspired this space-themed design!” — Designed by James Mitchell from the United Kingdom. - preview - without calendar: 1280x720, 1280x800, 1366x768, 1440x900, 1680x1050, 1920x1080, 1920x1200, 2560x1440, 2880x1800 Colorful Summer “‘Always keep mint on your windowsill in August, to ensure that the buzzing flies will stay outside where they belong. Don’t think summer is over, even when roses droop and turn brown and the stars shift position in the sky. Never presume August is a safe or reliable time of the year.’ (Alice Hoffman)” — Designed by Lívi from Hungary. - preview - without calendar: 800x480, 1024x768, 1280x720, 1280x1024, 1400x1050, 1680x1050, 1680x1200, 1920x1200, 2560x1440, 3475x4633 Smoky Mountain Bigfoot Conference “Headed towards Smoky Mountain Bigfoot Conference this summer? Oh, they say it’s gonna be a big one! Get yourself out there well-prepared, armed with…", "metadata": {"source": "https://www.smashingmagazine.com/feed", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "medium", "clarity_score": 0.38, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.38}}
{"format": "sequential_text", "title": "Primer on Python Decorators", "text": "In this tutorial, you'll look at what Python decorators are and how you define and use them. Decorators can make your code more readable and reusable. Come take a look at how decorators work under the hood and practice writing your own decorators.", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.9, "logical_leap_found": false, "steps_support_conclusion": true, "counterargument_found": false, "judge_source": "llm_judge", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.9}}
{"format": "sequential_text", "title": "Build command-line face recognition tool with Python", "text": "In this tutorial, you'll build your own face recognition command-line tool with Python. You'll learn how to use face detection to identify faces in an image and label them using face recognition. With this knowledge, you can create your own face recognition tool from start to finish!", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 1, "logical_leap_found": false, "steps_support_conclusion": true, "counterargument_found": false, "judge_source": "llm_judge", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 1.0}}
{"format": "sequential_text", "title": "Install Ollama, pull models, connect Python with chat/text interfaces.", "text": "Learn how to install Ollama, pull local models, and connect them to your Python code using the chat and text generation interfaces.", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.6, "logical_leap_found": true, "steps_support_conclusion": true, "counterargument_found": true, "judge_source": "llm_judge", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.25}}
{"format": "sequential_text", "title": "Python async programming uses async/await for concurrent I/O", "text": "Learn how Python async programming works. Write async functions with async and await, and run slow I/O operations concurrently with asyncio.", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.35, "logical_leap_found": null, "steps_support_conclusion": null, "counterargument_found": null, "judge_source": "heuristic_fallback", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.35}}
{"format": "sequential_text", "title": "Quiz: Async Programming in Python: From Generators to…", "text": "Test your understanding of async features in Python, including async and await, blocking versus non-blocking code, and the event loop.", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.7, "logical_leap_found": false, "steps_support_conclusion": false, "counterargument_found": false, "judge_source": "llm_judge", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.4}}
{"format": "sequential_text", "title": "The Real Python Podcast – Episode #309: Exploring…", "text": "What are the key characteristics of complex systems, and what are practical patterns for tackling complex coding problems? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.3, "logical_leap_found": true, "steps_support_conclusion": false, "counterargument_found": false, "judge_source": "llm_judge", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.0}}
{"format": "sequential_text", "title": "Quiz: Rock, Paper, Scissors With Python: A Command…", "text": "Check your understanding of building a command line rock paper scissors game in Python, from player input and loops to enums and dictionary rules.", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.8, "logical_leap_found": false, "steps_support_conclusion": true, "counterargument_found": false, "judge_source": "llm_judge", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": true, "confidence_weight": 0.8}}
{"format": "sequential_text", "title": "Install, setup, and manage Claude Code with Git", "text": "Test your Claude Code basics: install it, set it up, work with CLAUDE.md, and use Git to stay in control of your changes.", "metadata": {"source": "https://realpython.com/atom.xml", "category": "code", "subcategory": "general_programming", "language": "en", "difficulty": "easy", "clarity_score": 0.6, "logical_leap_found": false, "steps_support_conclusion": false, "counterargument_found": false, "judge_source": "llm_judge", "code_checked": false, "code_ok": null, "math_checked": false, "math_ok": null, "verified": false, "confidence_weight": 0.3}}