並び順

ブックマーク数

期間指定

  • から
  • まで

1 - 40 件 / 139件

新着順 人気順

for loop for objects in javascriptの検索結果1 - 40 件 / 139件

  • Google TypeScript Style Guide

    // Good: choose between two options as appropriate (see below). import * as ng from '@angular/core'; import {Foo} from './foo'; // Only when needed: default imports. import Button from 'Button'; // Sometimes needed to import libraries for their side effects: import 'jasmine'; import '@polymer/paper-button'; Import paths TypeScript code must use paths to import other TypeScript code. Paths may be r

    • TabFS

      Going through the files inside a tab's folder. For example, the url.txt, text.txt, and title.txt files tell me those live properties of this tab (Read more up-to-date documentation for all of TabFS's files here.) This gives you a ton of power, because now you can apply all the existing tools on your computer that already know how to deal with files -- terminal commands, scripting languages, point-

        TabFS
      • neue cc - ゼロアロケーションLINQライブラリ「ZLinq」のリリースとアーキテクチャ解説

        ゼロアロケーションLINQライブラリ「ZLinq」のリリースとアーキテクチャ解説 2025-05-05 ZLinq v1を先月リリースしました!structとgenericsベースで構築することによりゼロアロケーションを達成しています。またLINQ to Span, LINQ to SIMD, LINQ to Tree(FileSystem, JSON, GameObject, etc.)といった拡張要素と、任意の型のDrop-in replacement Source Generator。そして.NET Standard 2.0, Unity, Godotなどの多くのプラットフォームサポートまで含めた大型のライブラリとなっています!現在GitHub Starsも2000を超えました。 https://github.com/Cysharp/ZLinq structベースのLINQそのものは

        • プロと読み解く Ruby 3.2 NEWS - クックパッド開発者ブログ

          技術部の笹田(ko1)と遠藤(mame)です。クックパッドで Ruby (MRI: Matz Ruby Implementation、いわゆる ruby コマンド) の開発をしています。お金をもらって Ruby を開発しているのでプロの Ruby コミッタです。 昨日 12/25 に、恒例のクリスマスリリースとして、Ruby 3.2.0 がリリースされました(Ruby 3.2.0 リリース)。今年も Ruby 3.2 の NEWS.md ファイルの解説をします。NEWS ファイルとは何か、は以前の記事を見てください。 プロと読み解く Ruby 2.6 NEWS ファイル - クックパッド開発者ブログ プロと読み解くRuby 2.7 NEWS - クックパッド開発者ブログ プロと読み解くRuby 3.0 NEWS - クックパッド開発者ブログ プロと読み解く Ruby 3.1 NEWS -

            プロと読み解く Ruby 3.2 NEWS - クックパッド開発者ブログ
          • Optimizing Javascript for fun and for profit

            I often feel like javascript code in general runs much slower than it could, simply because it’s not optimized properly. Here is a summary of common optimization techniques I’ve found useful. Note that the tradeoff for performance is often readability, so the question of when to go for performance versus readability is a question left to the reader. I’ll also note that talking about optimization n

            • The Prompt Engineering Playbook for Programmers

              Developers are increasingly relying on AI coding assistants to accelerate our daily workflows. These tools can autocomplete functions, suggest bug fixes, and even generate entire modules or MVPs. Yet, as many of us have learned, the quality of the AI’s output depends largely on the quality of the prompt you provide. In other words, prompt engineering has become an essential skill. A poorly phrased

                The Prompt Engineering Playbook for Programmers
              • GitHub - modelcontextprotocol/servers: Model Context Protocol Servers

                Official integrations are maintained by companies building production ready MCP servers for their platforms. 21st.dev Magic - Create crafted UI components inspired by the best 21st.dev design engineers. ActionKit by Paragon - Connect to 130+ SaaS integrations (e.g. Slack, Salesforce, Gmail) with Paragon’s ActionKit API. Adfin - The only platform you need to get paid - all payments in one place, in

                  GitHub - modelcontextprotocol/servers: Model Context Protocol Servers
                • How to refactor code with GitHub Copilot

                  We’ve all been there—staring at a function that looks like it was written by an over-caffeinated goblin at 3 AM (maybe even your alter ego). You could pretend it doesn’t exist, or you could refactor it. Luckily, GitHub Copilot makes the second option less painful. Let’s get to it. What is code refactoring? Feel free to breeze past this section if you already know what’s involved with refactoring c

                    How to refactor code with GitHub Copilot
                  • JavaScript Best Practices | The WebStorm Blog

                    IDEs CLion DataGrip DataSpell Fleet GoLand IntelliJ IDEA PhpStorm PyCharm RustRover Rider RubyMine WebStorm Plugins & Services Big Data Tools Code With Me JetBrains Platform Scala Toolbox App Writerside JetBrains AI Grazie Junie JetBrains for Data Kineto Team Tools Datalore Space TeamCity Upsource YouTrack Hub Qodana CodeCanvas .NET & Visual Studio .NET Tools ReSharper C++ Languages & Frameworks K

                      JavaScript Best Practices | The WebStorm Blog
                    • How modern browsers work

                      Note: For those eager to dive deep into how browsers work, an excellent resource is Browser Engineering by Pavel Panchekha and Chris Harrelson (available at browser.engineering). Please do check it out. This article is an overview of how browsers work. Web developers often treat the browser as a black box that magically transforms HTML, CSS, and JavaScript into interactive web applications. In tru

                        How modern browsers work
                      • Claude Code の使い方|npaka

                        「Claude Code」の使い方をまとめました。 ・Claude Code 1. Claude Code「Claude Code」は、Anthropicが開発したエージェントコーディングツールです。ターミナルに常駐し、コードベースを理解し、自然言語コマンドを通じてより速くコーディングできます。開発環境に直接統合することで、追加のサーバや複雑なセットアップなしにワークフローを合理化します。現在は研究プレビューとして提供されてます。 主な機能は次のとおりです。 ・コードベース全体のファイルの編集とバグの修正 ・コードのアーキテクチャとロジックに関する質問に回答 ・テスト、リンティング、その他のコマンドの実行と修正 ・Git履歴の検索、マージ競合の解決、コミットとPRの作成 「Claude API」の使用料金がかかります。 2. システム要件システム要件は、次のとおりです。 ・OS ・macO

                          Claude Code の使い方|npaka
                        • Inkbase: Programmable Ink

                          With pen and paper, anyone can write a journal entry, draw a diagram, perform a calculation, or sketch a cartoon. Digital tablets like the iPad or reMarkable can adapt pen and paper into the world of digital media. In doing so, they trade away some of paper’s advantages like cheapness and tangibility. In exchange, we get new computational powers like nondestructive editing and ease of transmission

                            Inkbase: Programmable Ink
                          • Announcing .NET 10 - .NET Blog

                            Today, we are excited to announce the launch of .NET 10, the most productive, modern, secure, intelligent, and performant release of .NET yet. It’s the result of another year of effort from thousands of developers around the world. This release includes thousands of performance, security, and functional improvements across the entire .NET stack-from languages and developer tools to workloads-enabl

                              Announcing .NET 10 - .NET Blog
                            • LogLog Games

                              The article is also available in Chinese. Disclaimer: This post is a very long collection of thoughts and problems I've had over the years, and also addresses some of the arguments I've been repeatedly told. This post expresses my opinion the has been formed over using Rust for gamedev for many thousands of hours over many years, and multiple finished games. This isn't meant to brag or indicate su

                              • Functional programming is finally going mainstream

                                Functional programming is finally going mainstream Object-oriented and imperative programming aren’t going away, but functional programming is finding its way into more codebases. Klint Finley // July 12, 2022 Paul Louth had a great development team at Meddbase, the healthcare software company he founded in 2005. But as the company grew, so did their bug count. That’s expected, up to a point. More

                                  Functional programming is finally going mainstream
                                • Spin 1.0 — The Developer Tool for Serverless WebAssembly

                                  We are delighted to introduce Spin 1.0, the first stable release of the open source developer tool for building serverless applications with WebAssembly (Wasm)! Since we first introduced Spin last year, we have been hard at work together with the community on building a frictionless developer experience for building and running serverless applications with Wasm. For this release, we focused on bui

                                    Spin 1.0 — The Developer Tool for Serverless WebAssembly
                                  • Patterns for Reactivity with Modern Vanilla JavaScript – Frontend Masters Blog

                                    “Reactivity” is how systems react to changes in data. There are many types of reactivity, but for this article, reactivity is when data changes, you do things. Reactivity Patterns are Core to Web Development We handle a lot with JavaScript in websites and web apps since the browser is an entirely asynchronous environment. We must respond to user inputs, communicate with servers, log, perform, etc.

                                      Patterns for Reactivity with Modern Vanilla JavaScript – Frontend Masters Blog
                                    • DuckDB-Wasm: Efficient Analytical SQL in the Browser

                                      TL;DR: DuckDB-Wasm is an in-process analytical SQL database for the browser. It is powered by WebAssembly, speaks Arrow fluently, reads Parquet, CSV and JSON files backed by Filesystem APIs or HTTP requests and has been tested with Chrome, Firefox, Safari and Node.js. You can try it in your browser at shell.duckdb.org or on Observable. DuckDB-Wasm is fast! If you're here for performance numbers, h

                                        DuckDB-Wasm: Efficient Analytical SQL in the Browser
                                      • Things we learned about LLMs in 2024

                                        31st December 2024 A lot has happened in the world of Large Language Models over the course of 2024. Here’s a review of things we figured out about the field in the past twelve months, plus my attempt at identifying key themes and pivotal moments. This is a sequel to my review of 2023. In this article: The GPT-4 barrier was comprehensively broken Some of those GPT-4 models run on my laptop LLM pri

                                          Things we learned about LLMs in 2024
                                        • A virtual DOM in 200 lines of JavaScript

                                          In this post I’ll walk through the full implementation of a Virtual DOM in a bit over 200 lines of JavaScript. The result is a full-featured and sufficiently performant virtual DOM library (demos). It’s available on NPM as the smvc package. The main goal is to illustrate the fundamental technique behind tools like React. React, Vue and the Elm language all simplify the creation of interactive web

                                          • Bringing Javascript to WebAssembly for Shopify Functions - Shopify

                                            Bringing Javascript to WebAssembly for Shopify FunctionsWhile we’re working on getting our Shopify Functions infrastructure ready for the public beta, we thought we’d use this opportunity to shine some light on how we brought JavaScript to WebAssembly, how we made everything fit within our very tight Shopify Function constraints, and what our plans for the future look like. At Winter Editions 2023

                                              Bringing Javascript to WebAssembly for Shopify Functions - Shopify
                                            • kyju.org - Piccolo - A Stackless Lua Interpreter

                                              Piccolo - A Stackless Lua Interpreter 2024-05-01 History of piccolo A "Stackless" Interpreter Design Benefits of Stackless Cancellation Pre-emptive Concurrency Fuel, Pacing, and Custom Scheduling "Symmetric" Coroutines and coroutine.yieldto The "Big Lie" Rust Coroutines, Lua Coroutines, and Snarfing Zooming Out piccolo is an interpreter for the Lua language written in pure, mostly safe Rust with a

                                              • Boost Node.js with V8 GC Optimization

                                                Optimizing Node.js Performance: V8 Memory Management & GC Tuning Prevent Crashes and Improve Latency by Understanding and Tuning V8's Garbage Collection for Your Node.js Application A common observation for Node.js developers is the seemingly continuous growth of their application's memory footprint, often measured by the Resident Set Size (RSS) reported by the operating system. This increasing RS

                                                  Boost Node.js with V8 GC Optimization
                                                • All JavaScript and TypeScript Features of the last 3 years

                                                  TypeScript as envisioned by Stable DiffusionThis article goes through almost all of the changes of the last 3 years (and some from earlier) in JavaScript / ECMAScript and TypeScript . Not all of the following features will be relevant to you or even practical, but they should instead serve to show what’s possible and to deepen your understanding of these languages. There are a lot of TypeScript fe

                                                    All JavaScript and TypeScript Features of the last 3 years
                                                  • Introducing the WebAssembly JavaScript Promise Integration API · V8

                                                    The JavaScript Promise Integration (JSPI) API allows WebAssembly applications that were written assuming synchronous access to external functionality to operate smoothly in an environment where the functionality is actually asynchronous. This note outlines what the core capabilities of the JSPI API are, how to access it, how to develop software for it and offers some examples to try out. What is ‘

                                                    • Low-Level Software Security for Compiler Developers

                                                      1 Introduction Compilers, assemblers and similar tools generate all the binary code that processors execute. It is no surprise then that these tools play a major role in security analysis and hardening of relevant binary code. Often the only practical way to protect all binaries with a particular security hardening method is to have the compiler do it. And, with software security becoming more and

                                                      • Why is building a UI in Rust so hard?

                                                        What Makes Rust Unique? Why is UI in Rust So Hard? Functional UI to the Rescue If you’ve read Hacker News recently, it’s hard to not think that Rust is the future: it’s being used in the Linux kernel and in the Android OS, by AWS for critical infrastructure, and in ChromeOS and Firefox. However, as wonderful as Rust is–it has yet to take off as a general language for building UI. In 2019, “GUI” wa

                                                          Why is building a UI in Rust so hard?
                                                        • Tao of Node - Design, Architecture & Best Practices

                                                          Tao of Node - Design, Architecture & Best Practices48 minute read One of the main benefits of JavaScript is that it runs both in the browser and the server. As an engineer you need to master a single language and your skills will have a variety of applications. This is what drew me to Node in 2015 - I didn’t have to switch between languages and tech stacks. Node allows you to reuse libraries, logi

                                                            Tao of Node - Design, Architecture & Best Practices
                                                          • AST vs. Bytecode: Interpreters in the Age of Meta-Compilation

                                                            233 AST vs. Bytecode: Interpreters in the Age of Meta-Compilation OCTAVE LAROSE, University of Kent, UK SOPHIE KALEBA, University of Kent, UK HUMPHREY BURCHELL, University of Kent, UK STEFAN MARR, University of Kent, UK Thanks to partial evaluation and meta-tracing, it became practical to build language implementations that reach state-of-the-art peak performance by implementing only an interprete

                                                            • Parsing SQL - Strumenta

                                                              The code for this tutorial is on GitHub: parsing-sql SQL is a language to handle data in a relational database. If you worked with data you have probably worked with SQL. In this article we will talk about parsing SQL. It is in the same league of HTML: maybe you never learned it formally but you kind of know how to use it. That is great because if you know SQL, you know how to handle data. However

                                                                Parsing SQL - Strumenta
                                                              • A new way to bring garbage collected programming languages efficiently to WebAssembly · V8

                                                                Show navigation A recent article on WebAssembly Garbage Collection (WasmGC) explains at a high level how the Garbage Collection (GC) proposal aims to better support GC languages in Wasm, which is very important given their popularity. In this article, we will get into the technical details of how GC languages such as Java, Kotlin, Dart, Python, and C# can be ported to Wasm. There are in fact two m

                                                                • Etsy Engineering | Etsy’s Journey to TypeScript

                                                                  Over the past few years, Etsy’s Web Platform team has spent a lot of time bringing our frontend code up to date. It was only a year and a half ago that we modernized our Javascript build system in order to enable advanced features, things like arrow functions and classes, that have been added to the language since 2015. And while this upgrade meant that we had futureproofed our codebase and could

                                                                    Etsy Engineering | Etsy’s Journey to TypeScript
                                                                  • Build an interactive WebGL experience with Next.js - Vercel

                                                                    Bring your creativity to life with the web's 3D graphic rendering API. WebGL is a JavaScript API for rendering 3D graphics within a web browser, giving developers the ability to create unique, delightful graphics, unlike anything a static image is capable of. By leveraging WebGL, we were able to take what would have been a static conference signup and turned it into the immersive Next.js Conf regi

                                                                      Build an interactive WebGL experience with Next.js - Vercel
                                                                    • GitHub - cloudflare/workerd: The JavaScript / Wasm runtime that powers Cloudflare Workers

                                                                      Server-first: Designed for servers, not CLIs nor GUIs. Standard-based: Built-in APIs are based on web platform standards, such as fetch(). Nanoservices: Split your application into components that are decoupled and independently-deployable like microservices, but with performance of a local function call. When one nanoservice calls another, the callee runs in the same thread and process. Homogeneo

                                                                        GitHub - cloudflare/workerd: The JavaScript / Wasm runtime that powers Cloudflare Workers
                                                                      • February 2021 (version 1.54)

                                                                        Join a VS Code Dev Days event near you to learn about AI-assisted development in VS Code. Update 1.54.1: The update addresses an issue with an extension dependency. Update 1.54.2: The update addresses these issues. Update 1.54.3: The update addresses this issue. Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap Welcome to the February 2021 release of Vi

                                                                          February 2021 (version 1.54)
                                                                        • WebGPU — All of the cores, none of the canvas — surma.dev

                                                                          WebGPU is an upcoming Web API that gives you low-level, general-purpose access GPUs. I am not very experienced with graphics. I picked up bits and bobs of WebGL by reading through tutorials on how to build game engines with OpenGL and learned more about shaders by watching Inigo Quilez do amazing things on ShaderToy by just using shaders, without any 3D meshes or models. This got me far enough to

                                                                            WebGPU — All of the cores, none of the canvas — surma.dev
                                                                          • Node.js

                                                                            Notable Changes Deprecations and Removals (SEMVER-MAJOR) fs: remove permissive rmdir recursive (Antoine du Hamel) #37216 (SEMVER-MAJOR) fs: runtime deprecate rmdir recursive option (Antoine du Hamel) #37302 (SEMVER-MAJOR) lib: runtime deprecate access to process.binding('http_parser') (James M Snell) #37813 (SEMVER-MAJOR) lib: runtime deprecate access to process.binding('url') (James M Snell) #377

                                                                              Node.js
                                                                            • HTML: The Programming Language

                                                                              Introduction HTML, the programming language, is a practical, turing-complete[1], stack-based programming language based on HTML, the markup language. It uses elements defined in HTML, the markup language, in order to do computations. To give you a sense of what HTML, the programming langauge, looks like, below is a sample program that prints the values from 1 to 10 to standard out (console.log) A

                                                                              • A Walk with LuaJIT

                                                                                The following is a chronicle of implementing a general purpose zero-instrumentation BPF based profiler for LuaJIT. Some assumptions are made about what this entails and it may be helpful to read some of our other work in this area. One major change from prior efforts is that instead of working with the original Parca unwinder we are now working with the OpenTelemetry eBPF profiler. If you missed t

                                                                                  A Walk with LuaJIT
                                                                                • 14 Linting Rules To Help You Write Asynchronous Code in JavaScript

                                                                                  Debugging asynchronous code in JavaScript can feel like navigating a minefield at times. You don't know when and where the console.logs will print out, and you have no idea how your code is executed. It's hard to correctly structure async code so it executes in the right order as you intend it to. Wouldn't it be nice if you had some guidance while writing asynchronous code, and to get a helpful me

                                                                                    14 Linting Rules To Help You Write Asynchronous Code in JavaScript