SmartCue

smartcue

Survey and Analysis of Smart Contract Quality Assurance: Conclusions, Acknowledgement and References

Survey and Analysis of Smart Contract Quality Assurance: Evaluation

Survey and Analysis of Smart Contract Quality Assurance: Defense Methodologies

Smarter than Grep: What Happens When You Let an LLM Read Your Logs?

Hello JavaScript Enthusiasts! Welcome to a new edition of “This Week in JavaScript”! This Week in JavaScript Today, we're exploring OpenAI's groundbreaking new models, important TC39 decisions, and a new high-performance JavaScript engine—plus exciting tool updates you won't want to miss! GPT-4.1, o3 and o4-mini, and Codex CLI: OpenAI’s Smartest Developer Tools GPT-4.1, o3 and o4-mini, and Codex CLI: OpenAI’s Smartest Developer Tools Together, these models and tools mark a shift from passive code suggestions to active, tool-using AI assistants that understand codebases, generate clean diffs, analyze logs, and even operate within the terminal. For JavaScript, full-stack, and backend developers, the implications are huge. GPT-4.1: Smarter, more precise, and built for real codebases GPT-4.1: Smarter, more precise, and built for real codebases GPT-4.1 introduces major upgrades that solve long-standing pain points in coding workflows: GPT-4.1 GPT-4.1 A 1 million token context window allows the model to work with entire codebases, multi-file apps, or full project documentation in a single go.
On the SWE-bench benchmark, GPT-4.1 hits 54.6% accuracy—a jump from GPT-4’s 33%. That means it solves far more real-world engineering tasks out of the box.
The model is trained for diff-style editing, which means instead of rewriting entire files, it returns clean, minimal code changes that can be reviewed or merged directly. A 1 million token context window allows the model to work with entire codebases, multi-file apps, or full project documentation in a single go. 1 million token context window On the SWE-bench benchmark, GPT-4.1 hits 54.6% accuracy—a jump from GPT-4’s 33%. That means it solves far more real-world engineering tasks out of the box. SWE-bench benchmark 54.6% accuracy The model is trained for diff-style editing, which means instead of rewriting entire files, it returns clean, minimal code changes that can be reviewed or merged directly. diff-style editing o3 and o4-mini: Agents that Think, Plan, and Act o3 and o4-mini: Agents that Think, Plan, and Act The o-series models add a layer of intelligent behavior that goes beyond code generation. The o-series models The o-series models These models can: These models can: Browse the web to fetch documentation or troubleshoot errors
Analyze uploaded files, logs, or datasets using Python
Understand screenshots and generate matching code or visuals
Create and manipulate images using DALL·E—all within the same conversation Browse the web to fetch documentation or troubleshoot errors Analyze uploaded files, logs, or datasets using Python Understand screenshots and generate matching code or visuals Create and manipulate images using DALL·E—all within the same conversation What makes them stand out is agentic behavior: the ability to reason through a problem, choose the right tools, and take action across multiple steps. agentic behavior For development use cases, this means: For development use cases, this means: Generating a custom Express backend with route logic and middleware
Analyzing error logs from production and returning structured insights
Translating hand-drawn wireframes into deployable front-end layouts Generating a custom Express backend with route logic and middleware Analyzing error logs from production and returning structured insights Translating hand-drawn wireframes into deployable front-end layouts This level of coordination turns the models into powerful assistants across the full software workflow. Codex CLI: AI Agent in the Terminal Codex CLI: AI Agent in the Terminal Codex CLI is a lightweight coding agent that runs locally in the terminal and connects to the user’s file system. It uses GPT-4.1 or o3 to interact with files, execute commands, and edit code through natural language instructions. Codex CLI Codex CLI Key capabilities include: Key capabilities include: Writing new features with natural prompts
Searching and summarizing code across large projects
Running scripts and interpreting outputs
Generating tests, documentation, and config files with minimal input Writing new features with natural prompts Searching and summarizing code across large projects Running scripts and interpreting outputs Generating tests, documentation, and config files with minimal input Codex CLI is fully open-source, and OpenAI is supporting its growth with a $1 million fund for projects built on top of it. $1 million fund Why This Matters Why This Matters This launch moves AI tools from reactive helpers to active collaborators. Instead of suggesting code in isolation, the models now understand context, plan across multiple steps, and even execute tasks locally via Codex CLI. The improvements in accuracy, reasoning, and usability make it possible to: accuracy reasoning usability Build faster
Debug with fewer mistakes
Create more consistent, production-ready outputs Build faster Debug with fewer mistakes Create more consistent, production-ready outputs For developers working in JavaScript, TypeScript, Python, or mixed stacks, this release offers a toolkit that integrates directly into existing workflows—and makes AI a far more practical part of daily development. JavaScript Records and Tuples are Dead JavaScript Records and Tuples are Dead At this month’s TC39 meeting, a major proposal was officially withdrawn: Records and Tuples, a long-running effort to bring deeply immutable data structures to JavaScript, has been shelved after several years of exploration. Records and Tuples Records and Tuples , But while one door closes, several new ones open. Records and Tuples: Proposal Withdrawn After Stalling at Stage 2 Records and Tuples: Proposal Withdrawn After Stalling at Stage 2 The Records and Tuples proposal aimed to introduce new primitive types for immutable values using special syntax like #{ x: 1 } and #[1, 2, 3 ]. It promised value-based equality and structural sharing—features developers often reach for when modeling data. #{ x: 1 } #[1, 2, 3 ] But the core idea faced growing concerns: It introduced new primitive types to the language
It required new syntax that many found awkward
It posed challenges for developer tooling and interop It introduced new primitive types to the language new primitive types It required new syntax that many found awkward new syntax It posed challenges for developer tooling and interop Despite years of refinement, the proposal failed to gain enough support to progress beyond Stage 2. As a result, it’s been withdrawn entirely. The functionality it aimed to deliver may return in a different form through Composite Keys, which offer value-based equality using regular JavaScript objects. Composite Keys Enums: TypeScript-Style Enums Enter Stage 1 Enums: TypeScript-Style Enums Enter Stage 1 A new Enum proposal has entered Stage 1, with the goal of bringing built-in enum support to JavaScript. The idea is to introduce a native enum syntax that aligns closely with TypeScript’s existing enum feature. Enum proposal This could mean: Cleaner declaration of constant sets
Better runtime compatibility with TypeScript enums
Easier modeling of state machines, role types, or status codes Cleaner declaration of constant sets Better runtime compatibility with TypeScript enums Easier modeling of state machines, role types, or status codes While the exact design is still evolving, the proposal advancing to Stage 1 signals serious interest in making enums part of the language natively. Deferred Re-exports: More Efficient Module Loading Deferred Re-exports: More Efficient Module Loading JavaScript modules may soon get a performance upgrade. The Deferred Re-exports proposal has reached Stage 2 and introduces the ability to selectively lazy-load re-exports. Deferred Re-exports This means developers could write: export defer { heavyTool } from './expensive.js';

export { fastTool } from './light.js'; export defer { heavyTool } from './expensive.js';

export { fastTool } from './light.js'; With this syntax, expensive.js will only load if heavyTool is actually imported. This opens the door to better tree-shaking, faster startup times, and smarter bundling strategies, especially in large libraries and frameworks. tree-shaking Map Upsert: Cleaner and Faster Key Management Map Upsert: Cleaner and Faster Key Management The Upsert proposal is nearing Stage 3 and would give developers a long-awaited method: Upsert proposal Map.prototype.getOrInsert Map.prototype.getOrInsert This pattern: if (!map.has(key)) {

map.set(key, defaultValue);

}

return map.get(key); if (!map.has(key)) {

map.set(key, defaultValue);

}

return map.get(key); Could become a single line: map.getOrInsert(key, () => defaultValue); map.getOrInsert(key, () => defaultValue); It’s more concise, avoids repeated lookups, and mirrors behavior found in other languages like Python and Rust. Great for caches, counters, and any scenario where maps are used as dynamic stores. Composite Keys: Value-Based Equality Without New Primitives Composite Keys: Value-Based Equality Without New Primitives Stepping in as a spiritual successor to Records and Tuples, Composite Keys have now entered Stage 1. They offer a new way to create objects that behave like value types—meaning two objects with the same structure and values will be considered equal. Composite Keys const one = Composite({ x: 1, y: 2 });

const two = Composite({ x: 1, y: 2 });

Composite.equal(one, two); // true const one = Composite({ x: 1, y: 2 });

const two = Composite({ x: 1, y: 2 });

Composite.equal(one, two); // true These can be used as Map or Set keys with value-based comparison, something that’s currently impossible with standard objects. If successful, this proposal could finally give JavaScript a clean and efficient way to model compound keys without resorting to stringification hacks. Map or Set keys What This Means for Developers What This Means for Developers The withdrawal of Records and Tuples may seem like a setback, but the momentum around Enums, Upsert, Composites, and smarter module loading shows TC39 is still actively evolving JavaScript toward more ergonomic, high-performance patterns. Many of these changes align closely with TypeScript workflows, making the future of JavaScript feel more familiar, more efficient, and more expressive. Keep an eye on these proposals. If they hit Stage 3 or 4 in the coming months, they could soon land in browsers, Node, or your next bundler release.Battle-Tested Node.js Testing Playbook Battle-Tested Node.js Testing Playbook Backend testing doesn’t have to be painful—and this GitHub repo proves it. Written like a no-fluff manual, it compiles over 50 hands-on strategies from real-world consulting work into one actionable playbook. Backend testing doesn’t have to be painful Backend testing doesn’t have to be painful What’s inside: What’s inside: Reliable patterns for mocking, Dockerized databases, flaky queue simulations, and message brokers
Test structures built around API routes and behavior-driven outcomes
A showcase Node.js app with 40+ tests (yes, including the DB) that all run in under five seconds Reliable patterns for mocking, Dockerized databases, flaky queue simulations, and message brokers Test structures built around API routes and behavior-driven outcomes A showcase Node.js app with 40+ tests (yes, including the DB) that all run in under five seconds If you're tired of flaky test suites and want a setup that runs fast and scales cleanly, this guide is gold. Hako: A High-Performance JavaScript Engine in a 800KB Box Hako: A High-Performance JavaScript Engine in a 800KB Box Hako is a new JavaScript engine focused on portability, performance, and security. Forked from PrimJS (an optimized QuickJS), it’s designed for embedding into any application with minimal overhead and maximum control. Hako Hako PrimJS Key highlights: Key highlights: WebAssembly-first architecture: Hako compiles to WASM, making it platform-agnostic and embeddable in any environment that supports WebAssembly. No need for native builds or complex bindings.
Built-in sandboxing and resource control: Runs securely within a WASM sandbox, with support for memory limits, execution quotas, and fail-fast controls to prevent abuse or denial-of-service scenarios.
Compact and fast: Weighs in at just ~800KB, starts quickly, and supports spinning up hundreds of lightweight VM instances. Ideal for plugins, serverless functions, and edge runtimes.
28% faster than QuickJS: Thanks to an improved interpreter and true garbage collection, Hako outperforms QuickJS in key benchmarks while retaining similar language coverage.
Modern JavaScript support: Supports ES2019+ features like modules, async/await, generators, BigInt, and more. Runs most modern JS code without issues.
Built-in debugging tools: Offers Chrome DevTools Protocol (CDP) support, allowing remote debugging via Chrome or VS Code. Rare among lightweight JS engines. WebAssembly-first architecture: Hako compiles to WASM, making it platform-agnostic and embeddable in any environment that supports WebAssembly. No need for native builds or complex bindings. WebAssembly-first architecture WASM Built-in sandboxing and resource control: Runs securely within a WASM sandbox, with support for memory limits, execution quotas, and fail-fast controls to prevent abuse or denial-of-service scenarios. Built-in sandboxing and resource control memory limits execution quotas fail-fast controls Compact and fast: Weighs in at just ~800KB, starts quickly, and supports spinning up hundreds of lightweight VM instances. Ideal for plugins, serverless functions, and edge runtimes. Compact and fast ~800KB 28% faster than QuickJS: Thanks to an improved interpreter and true garbage collection, Hako outperforms QuickJS in key benchmarks while retaining similar language coverage. 28% faster than QuickJS Modern JavaScript support: Supports ES2019+ features like modules, async/await, generators, BigInt, and more. Runs most modern JS code without issues. Modern JavaScript support Built-in debugging tools: Offers Chrome DevTools Protocol (CDP) support, allowing remote debugging via Chrome or VS Code. Rare among lightweight JS engines. Built-in debugging tools Chrome DevTools Protocol (CDP) Hako is best suited for developers building plugin systems, secure code sandboxes, lightweight REPLs, or cross-platform applications where running modern JS safely and efficiently is essential, and is faster than QuickJS, safer than Duktape, far lighter than V8, and more portable than Hermes. Tools & Releases You Should Know About Tools & Releases You Should Know About Let's speed-run through some of the other big tool updates this week! Astro 5.7: Introduces an experimental Fonts API supporting Google, Fontsource, and local files, plus a now-stable Sessions API for server-side data storage without cookies. SVG files can now be used directly as components.
WebStorm 2025.1: JetBrains' first major release of the year brings Claude model support to their AI Assistant, local model connections through Ollama, and improved Angular 17.2 signal query support.
tldts 7.0: This URL parsing utility now processes domains in microseconds with full Unicode compatibility, while adding email parsing and IPv6 detection.
Redux Toolkit 2.7: Adds Standard Schema validation support for RTK Query endpoints and fixes several bugs with infinite queries.
Babylon.js 8.3: Graphics improvements include native copy texture protocol and new post-processes like FXAA and film grain.
Bun v1.2.10: A mind-blowing performance boost for setImmediate (74 seconds → 4 milliseconds) makes Next.js builds 10% faster on macOS. Astro 5.7: Introduces an experimental Fonts API supporting Google, Fontsource, and local files, plus a now-stable Sessions API for server-side data storage without cookies. SVG files can now be used directly as components. Astro 5.7: WebStorm 2025.1: JetBrains' first major release of the year brings Claude model support to their AI Assistant, local model connections through Ollama, and improved Angular 17.2 signal query support. WebStorm 2025.1: tldts 7.0: This URL parsing utility now processes domains in microseconds with full Unicode compatibility, while adding email parsing and IPv6 detection. tldts 7.0: Redux Toolkit 2.7: Adds Standard Schema validation support for RTK Query endpoints and fixes several bugs with infinite queries. Redux Toolkit 2.7: Babylon.js 8.3: Graphics improvements include native copy texture protocol and new post-processes like FXAA and film grain. Babylon.js 8.3: Bun v1.2.10: A mind-blowing performance boost for setImmediate (74 seconds → 4 milliseconds) makes Next.js builds 10% faster on macOS. Bun v1.2.10: And that's it for the thirty-first issue of "This Week in JavaScript." This Week in JavaScript. Feel free to share this newsletter with a fellow developer, and make sure you're following for more weekly updates. Until next time, happy coding!

OpenAI Releases Its Smartest Developer Tools Yet

Authors:
(1) Yanpeng Ye, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia, GreenDynamics Pty. Ltd, Kensington, NSW, Australia, and these authors contributed equally to this work;
(2) Jie Ren, GreenDynamics Pty. Ltd, Kensington, NSW, Australia, Department of Materials Science and Engineering, City University of Hong Kong, Hong Kong, China, and these authors contributed equally to this work;
(3) Shaozhou Wang, GreenDynamics Pty. Ltd, Kensington, NSW, Australia (shaozhou@greendynamics.com.au);
(4) Yuwei Wan, GreenDynamics Pty. Ltd, Kensington, NSW, Australia and Department of Linguistics and Translation, City University of Hong Kong, Hong Kong, China;
(5) Imran Razzak, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia;
(6) Tong Xie, GreenDynamics Pty. Ltd, Kensington, NSW, Australia and School of Photovoltaic and Renewable Energy Engineering, University of New South Wales, Kensington, NSW, Australia (tong@greendynamics.com.au);
(7) Wenjie Zhang, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia (wenjie.zhang@unsw.edu.au). Editor’s note: This article is part of a broader study. You’re reading Part 8 of 9. Read the rest below. Table of Links Abstract and Introduction
Methods
Data preparation and schema design
LLMs training, evaluation and inference
Entity resolution
Knowledge graph construction
Result
Discussion
Conclusion and References Discussion In this research, we construct a functional material KG by fine-tuned LLMs and ensuring the traceability of all information. During the process, we encountered two main challenges and proposed corresponding solution: 1) Fine tuning LLM reduces the requirement for training set volume, but requires higher quality for each data in training set. when the quality of training dataset is limited, the performance of NER and RE is not good. Recursively generating training set data automatically from inference result is a good solution. High recall and precision data from each inference can be put into the training set after simple manual check. 2) Fine-tuned LLMs perform well on NER and RE task, but for ER task, they can not shows a same. However, the ER is also important in graph construction. To address the issue, we apply several ER methods and technologies including ChemDataExtractor, mat2Vec, Word Embedding Clustering and construct an expert dictionary storing information about energy material. Theses methods and technologies can not only achieve high perfromance ER task, but also remove some erroneous entities and relations. To better demonstrate the reliability of our method and FMKG, we compare them with existing structural information extraction method and material KG. We employ a similar approach to NERRE task of John Dagdelen et al.[21] to extract structured information from the text. The difference is that we have applied ER method to correct entities and relations, and finish ER tasks before graph construction. We evaluated our pipeline on NERRE’s evaluation dataset. It worth to mention that cross dataset evaluation allow for flexibility of multiple plausible annotations of an entity under different labels (e.g., "cathode" in NERRE is placed in "Application" label while our expert tend to place it in "Descriptor" since "cathode" and "anode" are component of "battery" which is an application.), and presented the results in a Table 5. From the results, it is evident that our pipeline has slightly lower recall across labels compared to the NERRE task, but our method holds a competitive edge in precision. This is because we believe that the primary goal of KG construction is to ensure the accuracy of the data. Hence, in the process of ER, our strategy tends to sacrifice a portion of recall in exchange for higher precision. However, when considering both recall and precision, our method scores higher in F1 across the "Acronym", "Application", "Structure/Phase", and "Descriptor" labels compared to NERRE, with the improvement in "Acronym" being particularly significant due to its lower precision in NERRE. This underscores the advantage of our ER pipeline and indirectly attests to the credibility of the FMKG. Knowledge graphs specifically dedicated to general materials are rare. In our discussion, we draw a comparison with MatKG2[15], showcasing the differences in construction methodologies between MatKG2 and FMKG, as depicted in the Figure 5. The construction of MatKG2 involves in a multi-step NER and RE pipeline, which can not catch the source of relations. In our method, we use end-to-end method that use a single LLM have been investigated for joint named entity recognition and relation extraction. It can not only catch keep source of each triple in KG so that enhance the factual basis of KG, but also perform better on RE task. KGs are always dynamic, especially in cutting-edge field such as material science. The LLM internalizes a large amount of knowledge during the training process, it can perform good inference even when new nodes and relationships appear, making KG easy to update. Besides, our work is a starting point where other material researchers can continue build FMKG using our result as training dataset, using our dictionary, ChemDataExtractor and mat2vec to achieve ER task, our method can also be extend to full paper, extract more functional material information to construct a larger and more comprehensive functional material knowledge graph. Besides, our pipeline can also be used in other specialized domains to construct domain-specific KGs. This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Yanpeng Ye, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia, GreenDynamics Pty. Ltd, Kensington, NSW, Australia, and these authors contributed equally to this work; (2) Jie Ren, GreenDynamics Pty. Ltd, Kensington, NSW, Australia, Department of Materials Science and Engineering, City University of Hong Kong, Hong Kong, China, and these authors contributed equally to this work; (3) Shaozhou Wang, GreenDynamics Pty. Ltd, Kensington, NSW, Australia (shaozhou@greendynamics.com.au); (4) Yuwei Wan, GreenDynamics Pty. Ltd, Kensington, NSW, Australia and Department of Linguistics and Translation, City University of Hong Kong, Hong Kong, China; (5) Imran Razzak, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia; (6) Tong Xie, GreenDynamics Pty. Ltd, Kensington, NSW, Australia and School of Photovoltaic and Renewable Energy Engineering, University of New South Wales, Kensington, NSW, Australia (tong@greendynamics.com.au); (7) Wenjie Zhang, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia (wenjie.zhang@unsw.edu.au). Authors: Authors: (1) Yanpeng Ye, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia, GreenDynamics Pty. Ltd, Kensington, NSW, Australia, and these authors contributed equally to this work; (2) Jie Ren, GreenDynamics Pty. Ltd, Kensington, NSW, Australia, Department of Materials Science and Engineering, City University of Hong Kong, Hong Kong, China, and these authors contributed equally to this work; (3) Shaozhou Wang, GreenDynamics Pty. Ltd, Kensington, NSW, Australia (shaozhou@greendynamics.com.au); (4) Yuwei Wan, GreenDynamics Pty. Ltd, Kensington, NSW, Australia and Department of Linguistics and Translation, City University of Hong Kong, Hong Kong, China; (5) Imran Razzak, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia; (6) Tong Xie, GreenDynamics Pty. Ltd, Kensington, NSW, Australia and School of Photovoltaic and Renewable Energy Engineering, University of New South Wales, Kensington, NSW, Australia (tong@greendynamics.com.au); (7) Wenjie Zhang, School of Computer Science and Engineering, University of New South Wales, Kensington, NSW, Australia (wenjie.zhang@unsw.edu.au). Editor’s note: This article is part of a broader study. You’re reading Part 8 of 9. Read the rest below. Editor’s note: This article is part of a broader study. You’re reading Part 8 of 9. Read the rest below. Editor’s note: This article is part of a broader study. You’re reading Part 8 of 9. Read the rest below. Table of Links Abstract and Introduction Methods Data preparation and schema design LLMs training, evaluation and inference Entity resolution Knowledge graph construction Result Discussion Conclusion and References Abstract and Introduction Abstract and Introduction Methods Methods Data preparation and schema design Data preparation and schema design LLMs training, evaluation and inference LLMs training, evaluation and inference Entity resolution Entity resolution Knowledge graph construction Knowledge graph construction Result Result Discussion Discussion Conclusion and References Conclusion and References Discussion In this research, we construct a functional material KG by fine-tuned LLMs and ensuring the traceability of all information. During the process, we encountered two main challenges and proposed corresponding solution: 1) Fine tuning LLM reduces the requirement for training set volume, but requires higher quality for each data in training set. when the quality of training dataset is limited, the performance of NER and RE is not good. Recursively generating training set data automatically from inference result is a good solution. High recall and precision data from each inference can be put into the training set after simple manual check. 2) Fine-tuned LLMs perform well on NER and RE task, but for ER task, they can not shows a same. However, the ER is also important in graph construction. To address the issue, we apply several ER methods and technologies including ChemDataExtractor, mat2Vec, Word Embedding Clustering and construct an expert dictionary storing information about energy material. Theses methods and technologies can not only achieve high perfromance ER task, but also remove some erroneous entities and relations. To better demonstrate the reliability of our method and FMKG, we compare them with existing structural information extraction method and material KG. We employ a similar approach to NERRE task of John Dagdelen et al.[21] to extract structured information from the text. The difference is that we have applied ER method to correct entities and relations, and finish ER tasks before graph construction. We evaluated our pipeline on NERRE’s evaluation dataset. It worth to mention that cross dataset evaluation allow for flexibility of multiple plausible annotations of an entity under different labels (e.g., "cathode" in NERRE is placed in "Application" label while our expert tend to place it in "Descriptor" since "cathode" and "anode" are component of "battery" which is an application.), and presented the results in a Table 5. From the results, it is evident that our pipeline has slightly lower recall across labels compared to the NERRE task, but our method holds a competitive edge in precision. This is because we believe that the primary goal of KG construction is to ensure the accuracy of the data. Hence, in the process of ER, our strategy tends to sacrifice a portion of recall in exchange for higher precision. However, when considering both recall and precision, our method scores higher in F1 across the "Acronym", "Application", "Structure/Phase", and "Descriptor" labels compared to NERRE, with the improvement in "Acronym" being particularly significant due to its lower precision in NERRE. This underscores the advantage of our ER pipeline and indirectly attests to the credibility of the FMKG. Knowledge graphs specifically dedicated to general materials are rare. In our discussion, we draw a comparison with MatKG2[15], showcasing the differences in construction methodologies between MatKG2 and FMKG, as depicted in the Figure 5. The construction of MatKG2 involves in a multi-step NER and RE pipeline, which can not catch the source of relations. In our method, we use end-to-end method that use a single LLM have been investigated for joint named entity recognition and relation extraction. It can not only catch keep source of each triple in KG so that enhance the factual basis of KG, but also perform better on RE task. KGs are always dynamic, especially in cutting-edge field such as material science. The LLM internalizes a large amount of knowledge during the training process, it can perform good inference even when new nodes and relationships appear, making KG easy to update. Besides, our work is a starting point where other material researchers can continue build FMKG using our result as training dataset, using our dictionary, ChemDataExtractor and mat2vec to achieve ER task, our method can also be extend to full paper, extract more functional material information to construct a larger and more comprehensive functional material knowledge graph. Besides, our pipeline can also be used in other specialized domains to construct domain-specific KGs. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Scientists Built a Smarter, Sharper Materials Graph by Teaching AI to Double-Check Its Work

Photo Courtesy of Dharmapada Behera Photo Courtesy of Dharmapada Behera Search Engine Optimization (SEO) used to be a messy, manual game, one part guesswork, two parts time sink, a jungle of disconnected tools, cryptic data, and constantly changing algorithms. The process felt like building a rocket ship with duct tape for small and mid-sized businesses trying to stand out online. That’s where Identable storms in, not with just another SEO tool, but with a unified AI-powered command center that doesn’t just keep up with digital trends, it writes the playbook. This isn’t about tweaking a few tags or chasing vanity metrics. It’s about letting automation do the heavy lifting, while you get back to building something meaningful. Identable Identable Unifying Digital Marketing Tools Unifying Digital Marketing Tools Most businesses have been duct-taping their digital strategy together with four or five separate tools, one for content, another for SEO, something else for social scheduling, and maybe one for analytics if there’s budget left. It’s bloated, chaotic, and expensive. Identifiable tosses that whole system out the window. Instead of juggling disconnected software, users get a single, intuitive dashboard that merges AI content creation, SEO optimization, lead generation, social media publishing, and analytics in one seamless interface. This is not a convenience upgrade, it is a strategic edge. The platform helps mid-sized firms cut marketing costs by up to 60 percent and claw back over 90 hours monthly by collapsing what used to take multiple platforms and countless hours into a unified system. That time can be spent on strategy, sales, or running your business instead of fighting with tech stacks and spreadsheets. Automating SEO for Real Results Automating SEO for Real Results SEO is still one of the highest-ROI channels in digital marketing but is also one of the most frustrating for most teams. Keyword research, audits, broken link fixes, and performance tracking are tedious. Identable’s SEO Agent is built with AI at its core. This tool automates the technical grunt work and turns SEO from a chore into a growth engine. It does not just hand you insights; it acts on them, whether fixing issues on your WordPress or Webflow site or suggesting new content ideas that will rank. What sets it apart is not just the automation, it is the intelligence behind it. The platform’s SEO Agent pulls live performance data, provides targeted recommendations, and generates white-labeled reports for agencies managing multiple clients. It is plug-and-play SEO that performs As Raza Sheikh, Founder and CEO of Identable, puts it, "Identable is the first AI-powered solution that integrates content creation, social media management, and SEO optimization into one seamless platform. Designed specifically for tech and SaaS companies, the platform helps businesses save 90 percent of their time and reduce costs by 60 percent." "Identable is the first AI-powered solution that integrates content creation, social media management, and SEO optimization into one seamless platform. Designed specifically for tech and SaaS companies, the platform helps businesses save 90 percent of their time and reduce costs by 60 percent." From Early Traction to Global Domination From Early Traction to Global Domination In an industry where launching a product often requires months of outreach and ad spend, Identable pulled off something remarkable: almost 300 users signed up organically, with no marketing push and zero human sales interaction. Over 60 percent of them are returning users. That kind of retention speaks louder than any campaign. It’s proof that what Identable has built isn’t just novel, it’s necessary. In the short term, Identable is laser-focused on driving adoption among SMEs and marketing agencies that need to do more with less. It will be the go-to digital growth platform for tech and SaaS companies worldwide in the mid-term. In the long run, it aims to rewire digital marketing, replacing manual processes with intelligent automation that drives consistent, compounding results. The company’s secret weapon is what they call the “Organic Marketing Flywheel,” a self-sustaining growth loop that attracts, engages, converts, delights, and advocates with minimal intervention. It’s a bold new take on marketing operations, especially for lean teams and agencies managing multiple brands. Sheikh explains, "The business expansion depends on research and development. I have witnessed how R&D fosters innovation, adjusts to shifting markets, boosts effectiveness, makes it easier to go worldwide, and ensures long-term sustainability." "The business expansion depends on research and development. I have witnessed how R&D fosters innovation, adjusts to shifting markets, boosts effectiveness, makes it easier to go worldwide, and ensures long-term sustainability." This article is published under HackerNoon’s Business Blogging program. This article is published under HackerNoon’s Business Blogging program. This article is published under HackerNoon’s Business Blogging program. This article is published under HackerNoon’s Business Blogging program. Business Blogging

Search Smarter, Not Harder: Identable Reinvents SEO With Intelligent Automation

Cerca més intel·ligent, no més difícil: Identificable reinventa SEO amb automatització intel·ligent

Έξυπνη αναζήτηση, όχι πιο δύσκολη: Αναγνωρίσιμη επανεφεύρεση SEO με έξυπνη αυτοματοποίηση

Búsqueda más inteligente, no más difícil: Identable reinventa SEO con automatización inteligente

Ricerca più intelligente, non più difficile: identificabile reinventa SEO con automazione intelligente

Search Smarter, Not Harder: Identable Reinvents SEO with Intelligent Automation よりスマートな検索、より難しい:識別可能なSEOをインテリジェントオートメーションで再発明

Paieška protingesnė, o ne sunkesnė: identifikuojamas iš naujo išrado SEO su pažangiu automatizavimu

Пребарувањето е попаметно, а не потешко: идентификуваното повторно го измислува оптимизацијата со интелигентна автоматизација

Căutare mai inteligentă, nu mai dificilă: Identifiabil reinventează SEO cu automatizare inteligentă

Search Smarter, Not Harder: Identable Reinventes SEO with Intelligent Automation - ஞானிகளின் தேடல்

Search Smart, akukho ngempumelelo: Identable Reinventes SEO nge Intelligent Automation

Search Smart, Not Harder: I-Identable Reinventes SEO nge-Intelligent Automation

Crypto Conferences Have a Vibe—and It’s Getting Realer, Smarter, and Way More Technical

Authors:
(1) Corby Rosset, Microsoft Research and Correspondence to corbyrosset@microsoft.com;
(2) Ching-An Cheng, Microsoft Research;
(3) Arindam Mitra, Microsoft Research;
(4) Michael Santacroce, Microsoft Research;
(5) Ahmed Awadallah, Microsoft Research and Correspondence to hassanam@microsoft.com;
(6) Tengyang Xie, Microsoft Research and Correspondence to tengyangxie@microsoft.com. Authors: Authors: (1) Corby Rosset, Microsoft Research and Correspondence to corbyrosset@microsoft.com; (2) Ching-An Cheng, Microsoft Research; (3) Arindam Mitra, Microsoft Research; (4) Michael Santacroce, Microsoft Research; (5) Ahmed Awadallah, Microsoft Research and Correspondence to hassanam@microsoft.com; (6) Tengyang Xie, Microsoft Research and Correspondence to tengyangxie@microsoft.com. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Preliminaries 2 Preliminaries 2.1 RLHF Based on Reward Models 2.1 RLHF Based on Reward Models 2.2 RLHF with General Preferences 2.2 RLHF with General Preferences 3 Direct Nash Optimization and 3.1 Derivation of Algorithm 1 3 Direct Nash Optimization and 3.1 Derivation of Algorithm 1 3.2 Theoretical Analysis 3.2 Theoretical Analysis 4 Practical Algorithm – Iterative Contrastive Self-Improvement 4 Practical Algorithm – Iterative Contrastive Self-Improvement 5 Experiments and 5.1 Experimental Setup 5 Experiments and 5.1 Experimental Setup 5.2 Results and Analysis 5.2 Results and Analysis 6 Related Work 6 Related Work 7 Conclusion and References 7 Conclusion and References Appendix Appendix A Extension to Regularized Preferences A Extension to Regularized Preferences B Detailed Proofs B Detailed Proofs C Additional Experimental Details C Additional Experimental Details Abstract This paper studies post-training large language models (LLMs) using preference feedback from a powerful oracle to help a model iteratively improve over itself. The typical approach for post-training LLMs involves Reinforcement Learning from Human Feedback (RLHF), which traditionally separates reward learning and subsequent policy optimization. However, such a reward maximization approach is limited by the nature of “point-wise” rewards (such as that of the Bradley-Terry model), which fails to express complex intransitive or cyclic preference relations. While advances on RLHF show reward learning and policy optimization can be merged into a single contrastive objective for stability, they yet still remain tethered to the reward maximization framework. Recently, a new wave of research sidesteps the reward maximization presumptions in favor of directly optimizing over “pair-wise” or general preferences. In this paper, we introduce Direct Nash Optimization (DNO), a provable and scalable algorithm that marries the simplicity and stability of contrastive learning with theoretical generality from optimizing general preferences. Because DNO is a batched on-policy algorithm using a regression-based objective, its implementation is straightforward and efficient. Moreover, DNO enjoys monotonic improvement across iterations which helps it improve even over a strong teacher (such as GPT-4). In our experiments, a resulting 7B parameter Orca-2.5 model aligned by DNO achieves the state-of-the-art win-rate against GPT-4-Turbo of 33% on AlpacaEval 2.0 (even after controlling for response length), an absolute gain of 26% (7% → 33%) over the initializing model. It outperforms models with far more parameters, including Mistral Large, Self-Rewarding LM (70B parameters), and older versions of GPT-4. Our ablation studies analyze critical design decisions surrounding the choice of preference pairs, and the use of LLMs-as-preference-annotators. These results underscore the promise of DNO in the LLMs post-training, as well as offer actionable insights for the AI research community. 1 Introduction The field of artificial intelligence is evolving towards advanced models that can understand, reason, follow complex instructions, and create nuanced content, while aligning with human values and preferences. Large Language Models (LLMs) (e.g., Brown et al., 2020; Ouyang et al., 2022; Touvron et al., 2023; OpenAI et al., 2023) have demonstrated remarkable capabilities in generating human-like text, answering questions, and coding, yet they still face challenges in tasks that require a high degree of reliability, safety, and ethical alignment. To address these challenges, fine-tuning LLMs using Reinforcement Learning from Human Feedback (RLHF) (Christiano et al., 2017; Bai et al., 2022a; Ouyang et al., 2022) has demonstrates strong potential for making LLMs more helpful by aligning them with human values. The RLHF framework has been long studied in the context of preference-based reinforcement learning (RL) or RL from human preferences (e.g., Knox and Stone, 2008; Akrour et al., 2012; Griffith et al., 2013; Wirth et al., 2017; Christiano et al., 2017). The conventional methods for RLHF typically assume that the preference is determined by a scalar reward function through some model, such as the frequently used Bradley-Terry (BT) model (Bradley and Terry, 1952).[1] RLHF then optimizes toward the preference in a two-step procedure: reward learning, and policy optimization (through RL) to maximize the learned reward. Under certain conditions, the two-step procedure can be streamlined into a single-step contrastive learning approach (Rafailov et al., 2023), eliminating the need for explicit reward learning. Algorithms of this kind (e.g., Rafailov et al., 2023, DPO) leverage the insight that a policy can be expressed equivalently by an “internal reward function” that the policy is optimal to, so they reduce the RLHF problem to regressing the policy’s internal reward function to that of the preference model. These algorithms are originally offline, and boast enhanced stability and ease of optimization. Nonetheless, two-step RLHF algorithms and their single-step contrastive variants still fundamentally rely on the reward maximization framework, wherein reward-based preferences are governed by, e.g., the BT model. The reward maximization framing poses a major limitation. Reward functions, defined to output a scalar score r(x, y) for a single response y to input x, cannot express general preferences y ≻ y ′ | x between a pair of outputs in all cases, e.g., intransitive or cyclic preferences (Elo, 1978). Hence, LLMs trained under reward maximization cannot always align with human preference. Furthermore, recent works show that even in settings where preferences can be perfectly expressed under the reward-based BT models, optimizing towards rewards yields problematic behaviors; we refer the reader to Bertrand et al. (2023); Azar et al. (2023); Munos et al. (2023) for more details. Lastly, reward functions in practice can quickly become “stale” as the distribution of the policy shifts under training (Ross et al., 2011; Cheng et al., 2023; Azar et al., 2023; Munos et al., 2023) – leaving them vulnerable to “reward hacking” (Amodei et al., 2016) We are motivated to overcome two separate challenges: the limited expressivity of reward-based RLHF, and the lack of clarity on how to scale up optimizing with respect to general preferences. Recent advances in reward-based optimization e.g., DPO, already have efficient and scalable implementations – we seek a similarly efficient solution under the framework of general preferences. We propose a provable and scalable RLHF algorithm – Direct Nash Optimization (DNO) (Algorithm 1) that achieves the best of both worlds, combining the scalability of contrastive objectives with the theoretical soundness of general preference optimization. DNO is designed as a batched on-policy algorithm with a regression-based learning objective; this design choice makes DNO stable and scalable, striking a balance between deployment efficiency and adaptability. Direct Nash Optimization Direct Nash Optimization We summarize at a high level the key ingredients and insights of DNO below. To address the issue that reward functions cannot express general preferences, we leverage recent insights that the notion of reward of ought to be expressed as expected win-rates with regard to a general preference function.[2]


To address the issue found in previous work that optimizing this more general objective with online algorithms is sample-inefficient or unstable, we decompose the learning procedure into a sequence of “batched on-policy” iterations, wherein each step instead optimizes a simple regression objective.


The regression objective (we choose binary cross-entropy) aligns the “internal reward function” of the policy to the expected win-rate compared with itself (as defined in Line 3 of Algorithm 1). By sampling outputs from the current policy to use for training (i.e., “self-play”), this procedure incentivizes self-improving behavior.


Our framework is general enough to admit off-policy samples into training, importantly, those from a more powerful teacher (See choice of µ1 and µ2 in Algorithm 1).


Furthermore, to ensure stability and computational efficiency, we propose a filtering scheme such that the reward regression is only performed on preference pairs with a sufficiently large margin (for theoretical explanation, see Section 4; in practice, see Section 5.2).


DNO repeats this procedure for multiple iterations to let the policy optimize toward the general preference. Since each step involves a regression problem it can be easily implemented at scale. To address the issue that reward functions cannot express general preferences, we leverage recent insights that the notion of reward of ought to be expressed as expected win-rates with regard to a general preference function.[2] To address the issue that reward functions cannot express general preferences, we leverage recent insights that the notion of reward of ought to be expressed as expected win-rates with regard to a general preference function.[2] To address the issue found in previous work that optimizing this more general objective with online algorithms is sample-inefficient or unstable, we decompose the learning procedure into a sequence of “batched on-policy” iterations, wherein each step instead optimizes a simple regression objective. To address the issue found in previous work that optimizing this more general objective with online algorithms is sample-inefficient or unstable, we decompose the learning procedure into a sequence of “batched on-policy” iterations, wherein each step instead optimizes a simple regression objective. The regression objective (we choose binary cross-entropy) aligns the “internal reward function” of the policy to the expected win-rate compared with itself (as defined in Line 3 of Algorithm 1). By sampling outputs from the current policy to use for training (i.e., “self-play”), this procedure incentivizes self-improving behavior. The regression objective (we choose binary cross-entropy) aligns the “internal reward function” of the policy to the expected win-rate compared with itself (as defined in Line 3 of Algorithm 1). By sampling outputs from the current policy to use for training (i.e., “self-play”), this procedure incentivizes self-improving behavior. Our framework is general enough to admit off-policy samples into training, importantly, those from a more powerful teacher (See choice of µ1 and µ2 in Algorithm 1). Our framework is general enough to admit off-policy samples into training, importantly, those from a more powerful teacher (See choice of µ1 and µ2 in Algorithm 1). Furthermore, to ensure stability and computational efficiency, we propose a filtering scheme such that the reward regression is only performed on preference pairs with a sufficiently large margin (for theoretical explanation, see Section 4; in practice, see Section 5.2). Furthermore, to ensure stability and computational efficiency, we propose a filtering scheme such that the reward regression is only performed on preference pairs with a sufficiently large margin (for theoretical explanation, see Section 4; in practice, see Section 5.2). DNO repeats this procedure for multiple iterations to let the policy optimize toward the general preference. Since each step involves a regression problem it can be easily implemented at scale. DNO repeats this procedure for multiple iterations to let the policy optimize toward the general preference. Since each step involves a regression problem it can be easily implemented at scale. Theoretically, we prove DNO converges to the intended Nash equilibrium on average, and that it can improve monotonically across iterations (see Section 3.1). Furthermore, our finite-sample analysis shows that approximation error at any iteration between the learned policy and the target is tightly bounded (Theorem 1). On the practical side, we provide a scalable implementation of DNO (Algorithm 2): an iterative self-improving algorithm with contrastive updates, which approximates Algorithm 1 under several critical design choices. Those choices include: sampling multiple online outputs from the policy being trained, using GPT-4 as the preference oracle, comparing onpolicy samples to GPT-4’s own (teacher) outputs, and training only on pairs with “large margin” (for theoretical explanation, see Section 4; in practice, see Section 5.2). The primary distinction of our work over related works of Nash-MD (Munos et al., 2023) and SPO (Swamy et al., 2024) is that they both exhibit sample efficiency issues (two timescale updates or sample-inefficient RL steps), and both use purely on-policy samples. We resolve the efficiency issue with a sample-efficient objective that works in practice, and DNO is more flexible to incorporate off-policy samples from e.g., a powerful teacher. Most importantly, DNO works in practice – we provide comprehensive empirical evaluations, resulting in state-of-the-art performance: • The resulting 7B parameter Orca-2.5 model, aligned using the practical implementation of DNO (Algorithm 2), achieves the state-of-the-art win-rate of any 7B model, exceeding 33% against GPT-4-Turbo beyond on the AlpacaEval 2.0, even after controlling for length. This is an over 26% absolute gain (7%→33%) compared to the initialized model. It outperforms several recent advanced closed-source models, including Mistral Large and GPT-4-0613, as well as open-source models with far more (10×) parameters, such as Self-Rewarding LM (Yuan et al., 2024) which has 70B parameters. • Our thorough ablation studies in Section 5.2 examine critical design touchpoints surrounding choice of loss function (supervised finetuning or contrastive), training paradigm (with or without on-policy samples), preference annotator quality (large margin or not), and training pair construction (self-play, teacher-vs-student, etc). Our findings highlight that carefully-crafted methods encoded in Algorithm 2 lead to substantial gains. • We show some examples of outputs across iterations which demonstrate qualitative improvements such as better addressing nuanced issues and presumptious questions (Table 5), better organization and clarity while refraining from making misleading statements (Table 6), and higher information density in answers (Table 7). We hope that the results presented herein will provide clarity to the community regarding the use of AI feedback for post-training LLMs. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv [1] We use “reward model” to denote a framework that translates preferences into rewards, e.g., Bradley-Terry, while “reward function” is a (possibly learned) function that outputs reward scalars.

The Art of Arguing With Yourself—And Why It’s Making AI Smarter

Umění hádat se sebou - a proč to dělá AI chytřejší

Kunsten at argumentere med dig selv - og hvorfor det gør AI smartere

El arte de discutir contigo mismo y por qué está haciendo que la IA sea más inteligente

自分と議論する芸術 - そしてなぜAIを賢くするのか

Pamba la Pamba la Pamba la 100% ya Pamba la 100% ya Pamba la 100% ya Pamba la 100% ya Pamba la 100% ya Pamba la 100% ya Pamba la 100% ya Pamba la 100% ya Pamba la 100% ya Pamba la 100%

The Art of Argumenting With Yourself – ແລະວິທີທີ່ມັນເຮັດໃຫ້ AI smarter

Уметноста да се расправате со себеси – и зошто ја прави вештачката интелигенција попаметна

A arte de discutir consigo mesmo – e por que está tornando a IA mais inteligente

Уметност расправљања са собом - и зашто то чини ИИ паметнијим

اپنے آپ کے ساتھ جھگڑا کرنے کا فن - اور کیوں یہ AI کو ذہین بناتا ہے

This article is part of the series: 'Towards Vaadin Developer Certification,' which aims to explain the fundamentals of Vaadin while I study for this certification. The topics covered here are an integral part of the 'Vaadin Developer' Certification. Styling in Vaadin goes beyond simple theme definitions. Some components, like Grid, require dynamic styling. Additionally, fonts and images must be properly managed within the theme folder. This article explores advanced styling techniques. Grid 1. Dynamic Styling in Grid Components 1. Dynamic Styling in Grid Components Grids often need row- or cell-specific styles based on data. This can be achieved using part names: Then, define styles in styles.css: styles.css 2. Lazy Loading Stylesheets 2. Lazy Loading Stylesheets If a stylesheet is required only in certain views, it can be loaded dynamically using @StyleSheet: @StyleSheet 3. Styling Using Custom Fonts 3. Styling Using Custom Fonts In Vaadin, custom fonts are treated as static resources, just like images or other assets. While the recommended approach is to leverage Vaadin’s built-in styling options, there are cases where overriding the default Lumo font style is necessary to achieve a unique look for your application. Below, we will guide you through the process of integrating a custom font into your Vaadin theme. 3.1 Steps to Define a Custom Font 3.1 Steps to Define a Custom Font a) Obtain the Font Files a) Obtain the Font Files You have two options to acquire the necessary font files: Google Fonts: Many fonts are freely available and can be used directly.
Font Conversion Tools: If you have a .TTF or .OTF font file, use an online tool such as Webfont Generator to convert it into web-friendly formats. Google Fonts: Many fonts are freely available and can be used directly. Google Fonts Font Conversion Tools: If you have a .TTF or .OTF font file, use an online tool such as Webfont Generator to convert it into web-friendly formats. Font Conversion Tools .TTF .OTF Once converted, the ZIP file will contain: .WOFF – Web Open Font Format (recommended for modern browsers)
.WOFF2 – Optimized version of .WOFF, offering better compression
stylesheet.css – Defines @font-face rules for the font .WOFF – Web Open Font Format (recommended for modern browsers) .WOFF .WOFF2 – Optimized version of .WOFF, offering better compression .WOFF2 .WOFF stylesheet.css – Defines @font-face rules for the font stylesheet.css @font-face b) Add the Font to Your Theme b) Add the Font to Your Theme Inside your project’s theme folder (frontend/themes/your-theme), create a new fonts directory and place the following files inside: frontend/themes/your-theme fonts c) Inject the Font into Your Stylesheet c) Inject the Font into Your Stylesheet Inside your theme’s global stylesheet (styles.css), import the font definitions: styles.css d) Override Lumo’s Default Font d) Override Lumo’s Default Font To apply the custom font across your entire application, override the --lumo-font-family property: --lumo-font-family Conclusion Conclusion Advanced styling in Vaadin includes dynamic grid styling, lazy-loaded stylesheets, and custom fonts. Mastering these techniques ensures highly customizable and performant applications. Disclaimer Disclaimer This content is drawn from studies and notes related to the Vaadin 24 certification. For deeper details, please consult the official documentation and learning materials for Vaadin certification. AI tools assisted in the structuring of this content; however, the writing and original content are solely done by the author. Authors Authors Paulo B. A. is an 'Oracle Certified Java Developer' and 'Spring Certified Professional' with a deep passion for Vaadin Flow. He crafts UIs with Vaadin and strives to make it the leading frontend framework for full-stack Java developers worldwide. He loves teaching, sharing knowledge, and creating content. While he enjoys learning theory through certifications, he always advocates for a practical approach. Linkedin.com/in/pbalves
X.com/p_b_alves
Mastodon.social/@pbalves Linkedin.com/in/pbalves X.com/p_b_alves Mastodon.social/@pbalves Staff Writer: Fábio A. P. is a technology enthusiast, self-taught writer, and scholar of society's relationship with technology. Passionate about sharing insights, he provides reliable perspectives on how technology shapes our lives. With clear and precise writing, Fábio simplifies complex topics, empowering readers to navigate the digital age with confidence. Staff Writer: Staff Writer: Medium.com/@fabioape Medium.com/@fabioape

Make Your Vaadin App Smarter, Prettier, and Faster With These Advanced Styling Hacks

Stories, News & Mentions about SMARTCUE

Categories

Trending Topics

Stories, News & Mentions about SMARTCUE

Smartcue’s Stories on HackerNoon

Categories

Trending Topics