they do not show that Go is as fast as Rust or Zig

A high loss scale in the L-BFGS-B minimizer, caused by averaging Huber-loss values over examples instead of summing them, which led to premature termination of the optimization.

An inital version is implemented in an ObservableHQ notebookwhere sets of lede sentences can be input.

The time from business to production workflow drops from months to days.

Although 85% of organizations say they want to be agentic within the next three years, 76% say their current operations and infrastructure can't support that change.

The impact on head counts depended on how AI was being used. It was specifically the jobs where tasks could be automated... that accounted for the decrease in employment—jobs for people like software developers. In jobs where AI was mainly used but to augment human work, head counts grew faster than the average for entry-level workers.

What company leaders face, he said, is not an innovation problem but an impatience problem.

The solution is: #undef signals #include "tensorflow/cc/saved_model/loader.h" #include "tensorflow/core/public/session.h" #define signals

The real issue is not whether defenders can get access to another model. It is whether they can turn model capability into something a security team can trust and use every day.

Research has shown that involving workers' perspectives in the design of workplace technologies promotes sustainable improvements in productivity and well-being.

The OpenAI team recently published a fantastic piece detailing the creation of their own internal data agent. It's a transparent detail of a very detailed and elegant implementation – but points to the long journey required to get there.

The OpenAI team recently published a fantastic piece detailing the creation of their own internal data agent. It's a transparent detail of a very detailed and elegant implementation – but points to the long journey required to get there.

The organizations that get this right won't be the ones that just automated the most tasks. They'll be the ones that figured out when the human should act, when the agent should act, and how the handoff between them works.

Workers lose the equivalent of 51 working days per year to technology friction — nearly two full months — up 42% from 2025.

If agents can execute all your ideas nearly as fast as you can prompt them, there's no point in implementing only your best idea. It might be better to implement your top three ideas all in parallel, but this makes it harder to stay organized.

You have to have people that have the ability to rethink the workflow at a scale that AI can execute, versus at a scale that humans can execute.

You have to have people that have the ability to rethink the workflow at a scale that AI can execute, versus at a scale that humans can execute.

highlights are incorporated into the input text with special markups, <extra_id_1> and <extra_id_2>, marking the beginning and end of each highlighted span, respectively. In our configuration, we set the maximum input length to 4096 and the maximum target length to 400. A greedy decoding strategy was used in order to optimize the decoding speed.

Our approach locates the longest common subsequence (LCS) between the lemmas of each input sentence and each summary sentence, followed by several heuristics to filter out irrelevant LCSs

For the summarization model, we used a BARTlarge model (Lewis et al., 2019) trained on the CNN/Daily Mail dataset (Hermann et al., 2015), selected for its noticeable popularity.

For the initial auto-consolidation, we deploy an available Controlled Text Reduction model (Slobodkin et al., 2023), which is a Flan-T5large model (Chung et al., 2022), finetuned on the highlights-focused CTR dataset.

we deploy the ExtractiveSummarizer model from the TransformerSum library. The model, a RoBERTabase (Liu et al., 2019) trained on the CNN/DailyMail summarization dataset (Hermann et al., 2015), operates as a binary classifier.

errors encountered during API calls are handled in two ways: handle within our system or delegate to users. We handle known LLM API errors that can be solved by user-side intervention. This would be in cases such as a Timeout or RateLimitError in OpenAI models

errors such as APIConnectionError in OpenAI models occur because of an issue with the LLM API server itself and requires intervention from OpenAI.

While MEGAnno+ is designed to support any open-source LLM or commercial LLM APIs, in this work, we only demonstrate OpenAI Completion models for clarity and brevity.

Data Model MEGAnno+ extends MEGAnno's data model where data Record, Label, Annotation, Metadata (e.g., text embedding or confidence score) are persisted in the service database along with the task Schema.

To implement our system as an extension to MEGAnno (Zhang et al., 2022), an in-notebook exploratory annotation tool.

MEGAnno+ is designed to provide a convenient and robust workflow for users to utilize LLMs in text annotation. To use our tool, users operate within their Jupyter notebook (Kluyver et al., 2016) with the MEGAnno+ client installed.

Initial prototype of browser.html was written in plain JS, but as scope grow it started to be unmanageable. React was new hotness, which we have explored but were disappointed by performance and a difficulty of working with non-standard web components. This lead me to develop reflex that featured swappable view drivers (doing virtual/real DOM diff/patch) and was heavily inspired by The Elm Architecture. DominionRunning complex JS UI logic in the UI thread meant dropped frame sooner or later.

Take interpreted vs compiled. Previously a property of the *language*

Languages come in four rough performance buckets, from slowest to fastest

This makes questions like “how fast is WebAssembly” a bit hard to answer. You don’t ask how fast algebraic notation is—it’s not a very sensible question. Taken in the context of something like JavaScript, the language is only as fast as the engine running it. JavaScript the language has no speed, but you can benchmark JS engines like V8, SpiderMonkey, and JavaScriptCore. You can benchmark the IO libraries of JS runtimes like Bun, Deno, and Node. What people actually mean is “how useful are the constructs of this language to efficient mappings of modern hardware” and “what is the current landscape of systems taking advantage of these constructs”.

fix list …

fix langchain callback injection

https://www.tensorflow.org/text/tutorials/text_generation document is failing in the Tensorflow v2.17 which contains Keras3.0. Modified the code to the Keras2.0.

Fix NVCC+Clang build failure. …

"""Handles loading of plugins.""" import importlib.util import inspect import json import os import sys import zipfile from pathlib import Path from typing import List from urllib.parse import urlparse from zipimport import zipimporter import yaml import openapi_python_client import requests from auto_gpt_plugin_template import AutoGPTPluginTemplate from openapi_python_client.config import Config as OpenAPIConfig from autogpt.config.config import Config from autogpt.logs import logger from autogpt.models.base_open_ai_plugin import BaseOpenAIPlugin DEFAULT_PLUGINS_CONFIG_FILE = os.path.join( os.path.dirname(os.path.abspath(file)), "..", "..", "plugins_config.yaml" ) class PluginConfig: def init(self, plugin_dict): self.plugin_dict = plugin_dict def is_enabled(self, plugin_name): return self.plugin_dict.get(plugin_name, {}).get('enabled', False) with open(DEFAULT_PLUGINS_CONFIG_FILE, "r") as file: plugins_dict = yaml.safe_load(file) plugins_config = PluginConfig(plugins_dict) def scan_plugins(config: Config, debug: bool = False) -> List[AutoGPTPluginTemplate]: """Scan the plugins directory for plugins and loads them. Args: config (Config): Config instance including plugins config debug (bool, optional): Enable debug logging. Defaults to False. Returns: List[Tuple[str, Path]]: List of plugins. """ loaded_plugins = [] plugins_path_path = Path(config.plugins_dir) # Directory-based plugins for plugin_path in [f.path for f in os.scandir(config.plugins_dir) if f.is_dir()]: if plugin_path.startswith("__"): # Avoid going into __pycache__ or other hidden directories continue plugin_module_path = plugin_path.split(os.path.sep) plugin_module_name = plugin_module_path[-1] qualified_module_name = ".".join(plugin_module_path) __import__(qualified_module_name) plugin = sys.modules[qualified_module_name] if not plugins_config.is_enabled(plugin_module_name): logger.warn(f"Plugin {plugin_module_name} found but not configured") continue for _, class_obj in inspect.getmembers(plugin): if hasattr(class_obj, "_abc_impl") and AutoGPTPluginTemplate in class_obj.__bases__: loaded_plugins.append(class_obj()) return loaded_plugins def inspect_zip_for_modules(zip_path: str, debug: bool = False) -> list[str]: """ Inspect a zipfile for a modules. Args: zip_path (str): Path to the zipfile. debug (bool, optional): Enable debug logging. Defaults to False. Returns: list[str]: The list of module names found or empty list if none were found. """ result = [] with zipfile.ZipFile(zip_path, "r") as zfile: for name in zfile.namelist(): if name.endswith("__init__.py") and not name.startswith("__MACOSX"): logger.debug(f"Found module '{name}' in the zipfile at: {name}") result.append(name) if len(result) == 0: logger.debug(f"Module '__init__.py' not found in the zipfile @ {zip_path}.") return result def write_dict_to_json_file(data: dict, file_path: str) -> None: """ Write a dictionary to a JSON file. Args: data (dict): Dictionary to write. file_path (str): Path to the file. """ with open(file_path, "w") as file: json.dump(data, file, indent=4) def fetch_openai_plugins_manifest_and_spec(config: Config) -> dict: """ Fetch the manifest for a list of OpenAI plugins. Args: urls (List): List of URLs to fetch. Returns: dict: per url dictionary of manifest and spec. """ # TODO add directory scan manifests = {} for url in config.plugins_openai: openai_plugin_client_dir = f"{config.plugins_dir}/openai/{urlparse(url).netloc}" create_directory_if_not_exists(openai_plugin_client_dir) if not os.path.exists(f"{openai_plugin_client_dir}/ai-plugin.json"): try: response = requests.get(f"{url}/.well-known/ai-plugin.json") if response.status_code == 200: manifest = response.json() if manifest["schema_version"] != "v1": logger.warn( f"Unsupported manifest version: {manifest['schem_version']} for {url}" ) continue if manifest["api"]["type"] != "openapi": logger.warn( f"Unsupported API type: {manifest['api']['type']} for {url}" ) continue write_dict_to_json_file( manifest, f"{openai_plugin_client_dir}/ai-plugin.json" ) else: logger.warn( f"Failed to fetch manifest for {url}: {response.status_code}" ) except requests.exceptions.RequestException as e: logger.warn(f"Error while requesting manifest from {url}: {e}") else: logger.info(f"Manifest for {url} already exists") manifest = json.load(open(f"{openai_plugin_client_dir}/ai-plugin.json")) if not os.path.exists(f"{openai_plugin_client_dir}/openapi.json"): openapi_spec = openapi_python_client._get_document( url=manifest["api"]["url"], path=None, timeout=5 ) write_dict_to_json_file( openapi_spec, f"{openai_plugin_client_dir}/openapi.json" ) else: logger.info(f"OpenAPI spec for {url} already exists") openapi_spec = json.load(open(f"{openai_plugin_client_dir}/openapi.json")) manifests[url] = {"manifest": manifest, "openapi_spec": openapi_spec} return manifests def create_directory_if_not_exists(directory_path: str) -> bool: """ Create a directory if it does not exist. Args: directory_path (str): Path to the directory. Returns: bool: True if the directory was created, else False. """ if not os.path.exists(directory_path): try: os.makedirs(directory_path) logger.debug(f"Created directory: {directory_path}") return True except OSError as e: logger.warn(f"Error creating directory {directory_path}: {e}") return False else: logger.info(f"Directory {directory_path} already exists") return True def initialize_openai_plugins( manifests_specs: dict, config: Config, debug: bool = False ) -> dict: """ Initialize OpenAI plugins. Args: manifests_specs (dict): per url dictionary of manifest and spec. config (Config): Config instance including plugins config debug (bool, optional): Enable debug logging. Defaults to False. Returns: dict: per url dictionary of manifest, spec and client. """ openai_plugins_dir = f"{config.plugins_dir}/openai" if create_directory_if_not_exists(openai_plugins_dir): for url, manifest_spec in manifests_specs.items(): openai_plugin_client_dir = f"{openai_plugins_dir}/{urlparse(url).hostname}" _meta_option = (openapi_python_client.MetaType.SETUP,) _config = OpenAPIConfig( **{ "project_name_override": "client", "package_name_override": "client", } ) prev_cwd = Path.cwd() os.chdir(openai_plugin_client_dir) if not os.path.exists("client"): client_results = openapi_python_client.create_new_client( url=manifest_spec["manifest"]["api"]["url"], path=None, meta=_meta_option, config=_config, ) if client_results: logger.warn( f"Error creating OpenAPI client: {client_results[0].header} \n" f" details: {client_results[0].detail}" ) continue spec = importlib.util.spec_from_file_location( "client", "client/client/client.py" ) module = importlib.util.module_from_spec(spec) try: spec.loader.exec_module(module) finally: os.chdir(prev_cwd) client = module.Client(base_url=url) manifest_spec["client"] = client return manifests_specs def instantiate_openai_plugin_clients( manifests_specs_clients: dict, config: Config, debug: bool = False ) -> dict: """ Instantiates BaseOpenAIPlugin instances for each OpenAI plugin. Args: manifests_specs_clients (dict): per url dictionary of manifest, spec and client. config (Config): Config instance including plugins config debug (bool, optional): Enable debug logging. Defaults to False. Returns: plugins (dict): per url dictionary of BaseOpenAIPlugin instances. """ plugins = {} for url, manifest_spec_client in manifests_specs_clients.items(): plugins[url] = BaseOpenAIPlugin(manifest_spec_client) return plugins

Recommended Fix:

Added a null check in autogpt_platform/backend/backend/blocks/dataforseo/related_keywords.py to ensure items is never None before iterating Verified that existing tests still pass after the fix

My issue is usually generated by the browse function so im changing this: self.browse_chunk_max_length = int(os.getenv("BROWSE_CHUNK_MAX_LENGTH", 8192)) self.browse_summary_max_token = int(os.getenv("BROWSE_SUMMARY_MAX_TOKEN", 300)) To: self.browse_chunk_max_length = int(os.getenv("BROWSE_CHUNK_MAX_LENGTH", 2192)) self.browse_summary_max_token = int(os.getenv("BROWSE_SUMMARY_MAX_TOKEN", 300))

Looks like you're using Docker? If so, this worked for me: create auto-gpt.json in project root. mount auto-gpt.json with docker run command; e.g.:

Run a generative AI chatbot on Jetson Orin Nano Super Developer Kit. This chatbot features Ollama with Open WebUI, a widely used, open-source, chatbot server interface that connects to locally running LLMs.

Simply choosing a more efficient programming language speeds up this calculation

Autolinks do not work in MDX. The reason is that they can be indistinguishable from JSX (for example: <svg:rect>) and we prefer being explicit. If you want links, use full links: [descriptive text](https://and-the-link-here.com)

The reason for that is so you can nicely indent your components:

fortunately this is perfectly possible within existing company law by taking the concept the properties in law of legal personhood to their fullest extent

A TRUSTworthy repository needs to focus on serving its target user community. Each user community likely has differing expectations from their community repositories, depending in part on the community’s maturity regarding data management and sharing. A TRUSTworthy repository is embedded in its target user community’s data practices, and so can respond to evolving community requirements

TRUSTworthy repositories take responsibility for the stewardship of their data holdings and for serving their user community.

Sure, it is not needed, we can always write things in a different way. As a matter of fact, with such an argument, hardly any improvement should be accepted.

Composing Implementations

This implies that any correct run of the imple-mentation that stutters indefinitely has infinitely many opportunities to activatethe specification. Under the standard assumption that an opportunity that ispresented infinitely often is eventually seized, a live implementation does notdeadlock as it eventually activates the specification.

Live

Complete

Safe

An implementation is correct if it is safe, complete and live.

Given two transition systems T S = (S, s0, T ) and T S′ = (S′, s′0, T ′) an im-plementation of T S by T S′ is a function σ : S′ → S where σ(s′0) = s0.

Don't worry about performance too early though - it's more important to get the design right, and "right" in this case means using the database the way a database is meant to be used, as a transactional system.

SoNeC-FacilitatorNeighbourhood OrganiserCircle member in chargeNeighbours

I want the fact that my collection is lazy to be an implementation detail.

Generalist repositorie

linkages between rhetoric and practice still need to be further explored

Introduction of the Compose specification makes a clean distinction between the Compose YAML file model and the docker-compose implementation.

Current ruby releases generate *.tar.gz, *.tar.bz2, *.tar.xz, and *.zip. But I think we can stop generating *.tar.bz2. I think *.tar.bz2 are less merit. For better size, *.tar.xz exist. For better compatibility, *.tar.gz and *.zip exist.

Rijkswaterstaat beheert de zogenoemde FIS VNDS-database, waarin kenmerken van alle vaarwegen zijn opgenomen, zoals bijvoorbeeld de breedte van de vaarweg, bedientijden of de afmetingen van een sluis. Deze database bevat dus ook informatie van andere vaarwegbeheerders. ENC’s worden gemaakt en aangeleverd door de betreffende vaarwegbeheerder.

before that the support for parsing JSON in C was essential for using LSP servers

The S language is often the driver programming language for research in statistical methodology, and R gives an Open Source route to participation in that activity.

The modern implementation of S is R

The idea here is to emulate the hardware platform WordPerfect ran on

I avoided using languages that I don't know how to bootstrap like node.js

Typography in HTML is awful

Interestingly, Rails doesn't see this in their test suite because they set this value during setup:

Note that this is a reference implementation and, most likely, should be modified for your own usage.

Your character feels nigh impossible to control - you move very very fast, but if youre in the air, you dont stop moving the moment you stop holding a direction, so you have to constantly cancel out your momentum to stop, but if you dont do it perfectly you suddenly fly in the other direction

Most of the descriptions I’ve seen focus on mechanisms - block chains, smart contracts, tokens, etc - but I would argue those are implementation details and some are much more likely to succeed than others. (E.g. I think using private keys for authentication/authorization is obviously better if you can get over the UX hump - SSH has shown us that for decades.)

I am firmly convinced that asserting on the state of the interface is in every way superior to asserting on the state of your model objects in a full-stack test.

so let me explain why this decision was reached and what your options are for the future.

wait_until was removed for several reasons:

QueueStore

export interface QueueInterface {   count(): number;   dequeue?(): any;   enqueue(...args: any): void;   flush(): any[];   reset(): void;   setFifo(fifo: boolean): void;   setLifo(lifo: boolean): void;   truncate(length: number): void; } export class queue {   protected elements: any[];   protected fifo = true;   constructor(…args: any) {     this.elements = […args];   }   count() {     return this.elements.length;   }   dequeue?(): any {     if (this.fifo) {       return this.elements.shift();     }     return this.elements.pop();   }   enqueue(…args: any) {     return this.elements.push(…args);   }   // Like dequeue but will flush all queued elements   flush(): any[] {     let elms = [];     while (this.count()) {       elms.push(this.dequeue());     }     return elms;   }   setFifo(fifo = true) {     this.fifo = fifo;   }   setLifo(lifo = true) {     this.fifo = !lifo;   }   reset(): void {     this.truncate(0);   }   truncate(length: number) {     if (Number.isInteger(length) && length > -1) {       this.elements.length = length;     }   } } export default queue;

2019, c. 29, s. 301

Update API usage of the view helpers by changing javascript_packs_with_chunks_tag and stylesheet_packs_with_chunks_tag to javascript_pack_tag and stylesheet_pack_tag. Ensure that your layouts and views will only have at most one call to javascript_pack_tag or stylesheet_pack_tag. You can now pass multiple bundles to these view helper methods.

Their first step was to spend several weeks watching their customers

The automatic conversion not only confuses people but also makes the method less extensible. See [Feature #14183] for more details about the reasons for the change in behavior, and why certain implementation choices were made.

For me the diagrams make it easier to talk about what the tests do without getting bogged down by how they do it.

Do not test the internal implementation of the child components:

This might be exciting if the photography was better, but as it is, it's a simple concept cheaply implemented.

Tree (data structure)

Conversely, red tests are tests I write after the code is written to lock down some implementation.

There’s no need to test controllers, models, service objects, etc. in isolation

now that I realize how easy it is to just manually include this in my app: <%= javascript_include_tag 'xray', nonce: true if Rails.env.development? %> I regret even wasting my time getting it to automatically look for and add a nonce to the auto-injected xray.js script

Trailblazer offers you a new, more intuitive file layout in applications.

Instead of grouping by technology, classes and views are structured by concept, and then by technology. A concept can relate to a model, or can be a completely abstract concern such as invoicing.

Concepts over Technology

While Trailblazer offers you abstraction layers for all aspects of Ruby On Rails, it does not missionize you. Wherever you want, you may fall back to the "Rails Way" with fat models, monolithic controllers, global helpers, etc. This is not a bad thing, but allows you to step-wise introduce Trailblazer's encapsulation in your app without having to rewrite it.

It's an implementation of the command pattern in Ruby.

The more important point comes from a program design perspective. Here, "programming to an interface" means focusing your design on what the code is doing, not how it does it. This is a vital distinction that pushes your design towards correctness and flexibility.

If the program was important enough, Microsoft might actually go ahead and add some hack to their implementation so the the program would continue to work, but the cost of that is increased complexity (with all the ensuing problems) of the Windows code. It also makes life extra-hard for the Wine people, because they try to implement the WinAPI as well, but they can only refer to the documentation for how to do this, which leads to many programs not working as they should because they (accidentally or intentionally) rely on some implementation detail.

The press will tell you that "the concept" is great but the execution is bad. What should I tell you? The experience is shallow. The game is mediocre. But listen carefully, when a game is mediocre and can't even make you feel something then it's the worst kind of gaming. I will give it a 4 out of 10. You know, if this was a test in a school then this game should be marked D (someone answered a few questions, but overall missed the point). I understand that many people care about the "concept" of this game, but why if the experience is just... not here. I'm talking about the experience becaus We. The Revolution tried to be an actual experience. And it fails so badly.

I don't think this is what really matters at the end, since whatever is the implementation the goal should be to provide a library that people actually like to use.

I'm not familiar with Svelte. But the UI itself is handled in a custom canvas on mobile (and probably Desktop?) Though, on the web, it is HTML and CSS.

This decorators proposal deliberately omits these features, in order to keep the meaning of decorators "well-scoped" and intuitive, and to simplify implementations, both in transpilers and native engines.

However, this coalescing was very complicated, both in the specification and implementations, due to the dynamism of computed property names for accessors. Coalescing was a big source of overhead (e.g., in terms of code size) in polyfill implementations of "Stage 2" decorators.

There are a few intentional behavioral differences between Dart Sass and Ruby Sass. These are generally places where Ruby Sass has an undesired behavior, and it's substantially easier to implement the correct behavior than it would be to implement compatible behavior. These should all have tracking bugs against Ruby Sass to update the reference behavior.

Dart Sass has replaced Ruby Sass as the canonical implementation of the Sass language.

Dart Sass is the primary implementation of Sass, which means it gets new features before any other implementation. It’s fast, easy to install, and it compiles to pure JavaScript which makes it easy to integrate into modern web development workflows.

The freedesktop.org project also developed a free and open-source software library called libdbus, as a reference implementation of the specification. This library should not be confused with D-Bus itself, as other implementations of the D-Bus specification also exist

Typically, platform accessibility APIs do not provide a vehicle to notify assistive technologies of a role value change, and consequently, assistive technologies may not update their cache with the new role attribute value.