#AssemblyScript

[fraoula1]

𝐄𝐱𝐩𝐥𝐨𝐫𝐢𝐧𝐠 𝐭𝐡𝐞 𝐈𝐧𝐭𝐞𝐫𝐬𝐞𝐜𝐭𝐢𝐨𝐧 𝐨𝐟 𝐏𝐨𝐥𝐤𝐚𝐝𝐨𝐭, 𝐍𝐞𝐚𝐫 𝐏𝐫𝐨𝐭𝐨𝐜𝐨𝐥, 𝐚𝐧𝐝 𝐂𝐮𝐭𝐭𝐢𝐧𝐠-𝐄𝐝𝐠𝐞 𝐑𝐞𝐬𝐞𝐚𝐫𝐜𝐡

WebAssembly (WASM) is transforming the way developers approach web development and decentralized applications. With its promise of speed and scalability combined with the robustness of blockchain technology, WASM has become a vital tool in the ecosystems of Polkadot and Near Protocol—two of the most innovative platforms today. This blog post will examine how WASM is applied within these technologies, backed by statistical insights, research findings, and expert opinions.

The Rise of WebAssembly

WebAssembly, or WASM, is a binary instruction format that enables code execution on web browsers at nearly native speed. Since its introduction, WASM has seen rapid adoption across blockchain technologies. A report by the W3C states that more than 90% of modern web browsers now support WASM, leading to an upswing in its usage.

Research published in Blockchain Technology found that utilizing WASM can enhance the performance of decentralized applications (DApps) by anywhere from 10% to 20% compared to traditional JavaScript. This improvement is crucial for platforms like Polkadot and Near Protocol where speed and efficiency can make or break application success.

Polkadot: A Layered Architecture with WASM

Polkadot is at the forefront of blockchain innovation, offering a unique multi-chain architecture that allows different blockchains to operate together seamlessly. A key component of this technology is its use of WASM, empowering developers to write smart contracts in various programming languages, including Rust and C.

Recent statistics reveal that Polkadot's parachains are now processing over 1 million transactions each month. WASM is a significant driver behind this growth, providing lower latency and higher throughput. Data from Parity Technologies, the team behind Polkadot, shows that WASM has demonstrated a performance boost averaging 40% in microbenchmark tests.

The modular design of WASM affords easy upgrades and enhancements, enabling developers to adapt applications quickly to user needs. This flexibility has attracted over 200 active developers to the Polkadot ecosystem, as highlighted in a report from Dev.to.

Near Protocol: Emphasizing Usability and Accessibility

In contrast, Near Protocol prioritizes usability and developer experience, making blockchain technology more approachable for a broader audience. WASM serves a crucial role in this effort, allowing developers to build applications with speed and ease without compromising performance.

According to Near Protocol's reports, DApps built with WASM have seen a staggering 300% increase in user interactions compared to applications developed with traditional smart contract languages. This surge highlights how WASM simplifies the development process, enabling programmers to use familiar languages like AssemblyScript and Rust.

Additionally, the Near Protocol Foundation has invested in educating developers on how to utilize WASM. Their comprehensive guide has already been downloaded by more than 10,000 developers globally, illustrating the strong interest in WASM integration.

Research-Oriented Insights on WASM Adoption

Research consistently highlights the pressing need for innovative technologies like WASM to overcome existing blockchain challenges. A study in the Journal of Computer Science noted that 73% of developers believe WASM enhances their overall development experience. This aligns with findings in the Polkadot and Near ecosystems, where WASM promotes more efficient coding practices.

Organizations like the WebAssembly Community Group are emphasizing widespread adoption across various sectors. A recent survey revealed that 62% of developers working with blockchain technology actively explore incorporating WASM in their projects.

The collaboration between Polkadot and Near Protocol enhances the impact of WASM, as each project contributes its strengths. This partnership can lead to a more resilient, scalable, and user-friendly architecture.

The Future of WASM in Blockchain Technologies

The future of WASM in blockchain technologies is exceptionally bright, especially as Polkadot and Near Protocol continue to innovate. In 2023 alone, over $30 billion has been invested in blockchain research, highlighting the demand for solutions that are faster and more efficient.

According to a report from Deloitte, the need for faster transaction speeds and efficient programming solutions in blockchain will rise by 40% over the next five years. Thus, WASM could be the key technology driving this change.

Future advancements in WASM, including potential integration with AI-driven development tools, could further reinforce its role as a cornerstone of blockchain technology. These enhancements may include features like predictive performance analytics and automated code improvement suggestions.

Final Thoughts

The convergence of Polkadot, Near Protocol, and WebAssembly marks an exciting era for decentralized applications, characterized by speed, adaptability, and improved user experiences. The research, industry growth, and developer engagement clearly show that WASM is solidifying its position in the future of blockchain technologies.

As the landscape continues to evolve, it is evident that the potential for innovation with WASM in platforms like Polkadot and Near Protocol will be pivotal in shaping the next generation of scalable and efficient blockchain applications.

[weetechsolution]

6 Best WebAssembly Tools: A Developer's Toolkit

WebAssembly (Wasm) is a revolutionary innovation for the web development industry. Developers involved in any field can now use Wasm to build apps with the same speed and performance as the native applications and even offer great performance. To utilize the advantages of Wasm, developers can pick from a wide range of tools and frameworks.

6 Best WebAssembly Tools

1. Emscripten

Compiler: Emscripten is a powerful tool that enables the direct web application of all the C/C++ codes by converting these codes into web-readable format (WebAssembly modules).

Extensive Features: This software can flexibly support all the C/C++ features and the wide range of libraries makes it one of the best tools in the market for web application development.  

2. Rust

Language: Rust is a system programming language that can be transformed into WebAssembly by compiling, therefore, really fast and memory-safe.

Strong Community: Rust is an expanding and faithful community, which means it has plenty of resources and support.

3. AssemblyScript

TypeScript-Like Syntax: AssemblyScript is a syntax that is very close to TypeScript. Of course, it functions perfectly for JavaScript developers.

High Performance: The most and the ideally optimized WebAssembly code will be compiled ensuring that the performance will be, at least, satisfactory under normal circumstances.

4. WebAssembly Studio

WebAssembly Studio the online tool is an IDE that allows the development of WebAssembly modules, which can then be easily tested.

Functions: A feature that enables code editing, debugging, and performance analysis.

5. Binaryen

Optimizer: Binaryen has been developed as a compiler infrastructure for WebAssembly which is supplied with optimization tools focused on better code performance.

Flexibility: This product favors a multitude of different practices, including compilation, optimization, and analysis.

6. WasmEdge

Runtime Environment: WasmEdge is aimed at a lightweight and portable solution to run WebAssembly applications.

Security: Being equipped with the necessary security protections, it can thus be utilized for applications carrying highly sensitive data.

After WebAssembly, people who loved coding would be able to design these marvelous tools and how they would interact with the web. The tools you choose can let WebAssembly be fully released and you can make high-performance web apps.

[mitchellclark2296]

Embracing Innovation: Top 24 Web Designing Languages to Master in 2024

In the ever-evolving landscape of web development, staying updated with the latest languages is paramount for any designer or developer. As we venture into 2024, the realm of web design continues to witness transformative advancements, pushing boundaries and ushering in new possibilities.

Here’s a comprehensive guide to the top 24 web designing languages poised to shape the digital sphere in 2024:

Front-end Languages:

HTML (HyperText Markup Language): The cornerstone of web development, HTML remains indispensable for structuring web content.

CSS (Cascading Style Sheets): Essential for styling and presenting HTML elements, CSS empowers designers to create visually appealing websites.

JavaScript: A dynamic language facilitating interactive web elements, JavaScript remains a core language for front-end development.

TypeScript: Building on JavaScript, TypeScript brings static typing, aiding in the development of scalable and maintainable web applications.

Sass/SCSS: These CSS preprocessors enhance efficiency by introducing variables, nesting, and mixins, streamlining stylesheets.

Vue.js, React, Angular: These front-end frameworks continue to dominate, offering powerful tools for building robust, responsive, and interactive user interfaces.

Back-end Languages:

Python: Known for its readability and versatility, Python continues to be a preferred language for back-end development, thanks to frameworks like Django and Flask.

JavaScript (Node.js): Expanding its domain to server-side scripting with Node.js, JavaScript enables full-stack development, unifying front-end and back-end processes.

Ruby: Renowned for its simplicity and elegance, Ruby, coupled with the Rails framework, fosters rapid application development.

PHP: Despite criticisms, PHP remains prevalent, powering a significant portion of the web, especially with frameworks like Laravel and Symfony.

Golang (Go): Recognized for its speed and concurrency, Go is gaining traction in building scalable and efficient web applications.

Database Languages:

SQL (Structured Query Language): Fundamental for managing and querying relational databases, SQL expertise remains invaluable.

NoSQL (MongoDB, Firebase): Non-relational databases continue to rise, offering scalability and flexibility, suitable for modern web applications.

Markup Languages:

XML (Extensible Markup Language): Still utilized for specific applications, XML maintains relevance in data exchange and configuration.

JSON (JavaScript Object Notation): Lightweight and easy to parse, JSON is a preferred format for data exchange in web APIs.

Styling Languages:

Less: Similar to Sass/SCSS, Less simplifies CSS authoring with its dynamic stylesheet language.

PostCSS: Leveraging JavaScript plugins, PostCSS automates CSS processes, enhancing code efficiency and compatibility.

Specialized Languages:

Rust: Known for its safety features and performance, Rust is gaining attention for web assembly and system programming.

Elixir: Recognized for fault-tolerance and scalability, Elixir, with the Phoenix framework, excels in building real-time applications.

Emerging Languages:

Deno: Positioned as a secure runtime for JavaScript and TypeScript, Deno presents a potential alternative to Node.js.

Kotlin: Initially designed for Android, Kotlin’s conciseness and interoperability make it a contender for web development.

Web Assembly Languages:

AssemblyScript: A subset of TypeScript, AssemblyScript enables compiling TypeScript to WebAssembly for high-performance web applications.

Rust (WebAssembly): Utilizing Rust for WebAssembly empowers developers to create high-speed, low-level web applications.

Augmented Reality (AR) and Virtual Reality (VR) Languages:

Unity (C#): For immersive web experiences, Unity with C# supports the development of AR and VR applications on the web.

In the fast-paced world of web design, mastering these languages opens doors to innovation and empowers designers and developers to craft exceptional digital experiences. As 2024 unfolds, embracing these languages will be key to staying at the forefront of the ever-evolving web design landscape.

[this-week-in-rust]

This Week in Rust 471

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

Please welcome The 8472 to the Library team

Foundation

Secure App Development with Rust's Memory Model

Project/Tooling Updates

Announcing axum 0.6.0

Redox OS 0.8.0

Releasing Yew 0.20

rust-analyzer changelog #157

This Week in Fyrox

Fornjot (code-first CAD in Rust) - Weekly Release

Unimock 0.4

Slint 0.3.2 release

Extism: make all software programmable

Observations/Thoughts

Rust to assembly: Arrays, Tuples, Box, and Option handling

Improving async Rust codegen

rustdoc: Recent UI and UX changes in generated documentation 2

Rust Foundation in 2023-25

Follow-up to Foundation post

WebAssembly: TinyGo vs Rust vs AssemblyScript

Falsehoods programmers believe about undefined behavior

[video] Learning Rust the wrong way - Ólafur Waage - NDC TechTown 2022

[video] OS Development - One Year with Rust - by Bernhard Kauer

[video] Embedded Rust on ESP32 - Juraj Michálek

[audio] Leptos with Greg Johnston

[audio] Kanal with Khashayar Fereidani

Rust Walkthroughs

Threads and messages with Rust and WebAssembly

Migrating from warp to axum

Measuring the overhead of HashMaps in Rust

Building an API in Rust with Rocket.rs and Diesel.rs (Clean Architecture)

Avoiding Benchmarking Pitfalls with black_box in Rust

Embedded Rust & Embassy: UART Serial Communication

Rust GUI and GTK calc

Fearless concurrency: multithreaded unzip

[video] Typesafe Router state with Axum 0.6 release

Miscellaneous

JetBrains Rust developers survey

Crate of the Week

This week's crate is code-radio-cli, a command line interface for listening to freeCodeCamp's Code Radio music stream.

Thanks to 魏杰 for the suggestion!

Please submit your suggestions and votes for next week!

Call for Participation

Always wanted to contribute to open-source projects but didn't know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

pest - RFC: Make white-space handling less confusing / more consistent with the introduction of an "adjacent selector"

pest - two issues for the pest's website if anyone's into Wasm

site - migrate from stdweb to wasm-bindgen and websys

site - integrate a web version of pest_debugger

This week we also have a few non-rust-specific needs from your friends at This Week in Rust! Check them out:

this-week-in-rust - Add a dark theme

this-week-in-rust - Add anchors for headers

this-week-in-rust - Add a search

If you are a Rust project owner and are looking for contributors, please submit tasks here.

Updates from the Rust Project

389 pull requests were merged in the last week

add powerpc64-ibm-aix as Tier-3 target

stabilize native library modifier verbatim

use clang for the UEFI targets

optimize field ordering by grouping m×2ⁿ-sized fields with equivalently aligned ones

allow opaque types in trait impl headers and rely on coherence to reject unsound cases

allow power10-vector feature in PowerPC

branch Clause from Predicate

enable fuzzy_provenance_casts lint in liballoc and libstd

enable profiler in dist-riscv64-linux

lint: do not warn unused parens around higher-ranked function pointers

llvm-wrapper adapt for LLVM API change

make deref_into_dyn_supertrait lint the impl and not the usage

pass InferCtxt to DropRangeVisitor so we can resolve vars

pretty-print generators with their generator_kind

privacy: fix more (potential) issues with effective visibilities

properly handle Pin<&mut dyn* Trait> receiver in codegen

resolve: don't use constructor def ids in the map for field names

separate lifetime ident from lifetime resolution in HIR

stricter alignment enforcement for ScalarPair and Vector

suggest .clone() or ref binding on E0382

miri: fix handling of spurious accesses during retag

miri: make no_std work on Windows

miri: track local frames incrementally during execution

miri: use .wasm extension when building for wasm in cargo-miri

use an IndexVec to cache queries with index-like key

fix perf regression by correctly matching keywords

rustc_metadata: switch module children decoding to an iterator

codegen_gcc: fix simd_bitmask

codegen_gcc: fix the argument order for some AVX-512 intrinsics

don't build compiler_builtins with -C panic=abort

manually implement PartialEq for Option<T> and specialize non-nullable types

stop peeling the last iteration of the loop in Vec::resize_with

constify remaining Layout methods

mark sys_common::once::generic::Once::new const-stable

add slice methods for indexing via an array of indices

futures: stream::size_hint for mpsc channels

futures: custom Debug implementations for mpsc

futures: remove Debug constraint for oneshot types

portable SIMD: avoid a scalar loop in Simd::from_slice

regex: speed up replacen loop

rustc_codegen_ssa: write .dwp in a streaming fashion

cargo: add error message for cargo fix on an empty repo

cargo: add suggestions when cargo add multiple packages

cargo: store the sparse+ prefix in the SourceId for sparse registries

rustdoc: improve popover focus handling JS

bindgen: add --wrap-unsafe-ops option

bindgen: add ParseCallbacks::process_comment

bindgen: deprecate Rust targets lower or equal than 1.30

bindgen: escape method fragments that happen to be rust keywords

bindgen: remove traits that have a single implementation

clippy: add clippy_utils::msrv::Msrv to keep track of the current MSRV

clippy: add allow-mixed-uninlined-format-args config

clippy: fix unnecessary_to_owned false positive

clippy: fix redundant_closure_for_method_calls suggestion

clippy: fix unnecessary_lazy_eval when type has significant drop

clippy: lint unnecessary safety comments

clippy: re-enable uninlined_format_args on multiline format!

clippy: remove blank lines when needless_return returns no value

rust-analyzer: add deriveHelper to semanticTokenTypes section of package.json

rust-analyzer: add assist to generate trait impl's

rust-analyzer: adds hover hint to ".." in record pattern

rust-analyzer: check tail expressions more precisely in extract_function

rust-analyzer: filter unnecessary completions after colon

rust-analyzer: handle empty checkOnSave/target values

rust-analyzer: handle sysroot config in detached-files workspaces

rust-analyzer: tuple to named struct inside macros

rust-analyzer: hir-expand: fix compile_error! expansion not unquoting strings

rust-analyzer: improve goto declaration

rust-analyzer: properly implement Drop for JodGroupChild

rust-analyzer: suppress "Implement default members" inside contained items

cargo-bisect-rustc: --start without --end defaults end to be today

cc-rs: refine CUDA support

Rust Compiler Performance Triage

A relatively quiet week for performance, with the notable exception of "Avoid GenFuture shim when compiling async constructs #104321" which brought sizeable wins on a number of stress test benchmarks. It probably won't be of huge benefit to most codebases, but should provide smaller wins to folks with large amounts of async-generated futures.

Triage done by @simulacrum. Revision range: a78c9bee..8a09420a

3 Regressions, 3 Improvements, 6 Mixed; 2 of them in rollups 43 artifact comparisons made in total

See the full report for details.

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

No RFCs issued a call for testing this week.

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

Restrictions

Add lang-team advisors team

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

[disposition: merge] RFC: c"…" string literals

Tracking Issues & PRs

[disposition: merge] Remove const eval limit and implement an exponential backoff lint instead

[disposition: merge] Windows: make Command prefer non-verbatim paths

New and Updated RFCs

No New or Updated RFCs were created this week.

Upcoming Events

Rusty Events between 2022-11-30 - 2022-12-28 🦀

Virtual

2022-11-30 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Common crates and their usage

2022-11-30 | Virtual (Munich, DE) | Rust Munich

Rust Munich 2022 / 3 - hybrid

2022-12-01 | Virtual (Charlottesville, VA, US) | Charlottesville Rust Meetup

Exploring USB with Rust

2022-12-01 | Virtual (Lehi, UT, US) | Utah Rust

Beginner Projects and Shop Talk with Food!

2022-12-01 | Virtual (Redmond, WA, US) | Microsoft Reactor Redmond

Getting Started with Rust: Understanding Rust Compile Errors – Part 2

2022-12-06 | Virtual (Berlin, DE) | Berlin.rs

Rust Hack and Learn

2022-12-06 | Virtual (Buffalo, NY, US) | Buffalo Rust Meetup

Buffalo Rust User Group, First Tuesdays

2022-12-07 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2022-12-07 | Virtual (Stuttgart, DE) | Rust Community Stuttgart

Rust-Meetup

2022-12-08 | Virtual (Nürnberg, DE) | Rust Nuremberg

Rust Nürnberg online #20

2022-12-08 | Virtual (San Francisco, CA, US) | Data + AI Online Meetup

D3L2: The Genesis of Delta Rust with QP Hou

2022-12-10 | Virtual | Rust GameDev

Rust GameDev Monthly Meetup

2022-12-13 | Virtual (Dallas, TX, US) | Dallas Rust

Second Tuesday

2022-12-13 | Virtual (Rostock, DE) | Altow Academy

Rust Meetup Rostock

2022-12-13 | Virtual (Saarbrücken, DE) | Rust-Saar

Meetup: 25u16

2022-12-14 | Virtual (Boulder, CO, US) | Boulder Elixir and Rust

Monthly Meetup

2022-12-14 | Virtual (México City, MX) | Rust MX

Rust y Arduino

2022-12-15 | Virtual (Stuttgart, DE) | Rust Community Stuttgart

Rust-Meetup

2022-12-20 | Virtual (Berlin, DE) | Berlin.rs

Rust Hack and Learn

2022-12-20 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2022-12-21 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2022-12-27 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

Europe

2022-11-30 | Amsterdam, NL | Rust Nederland

Rust in Critical Infrastructure

2022-11-30 | Lille, FR | Rust Lille

Rust Lille #1

2022-11-30 | Milan, IT | Rust Language Milano

Welcome GAT!!

2022-11-30 | Munich, DE + Virtual | Rust Munich

Rust Munich 2022 / 3 - hybrid

2022-11-30 | Paris, FR | Rust Paris

Rust Paris meetup #54

2022-12-01 | Edinburgh, UK | Rust Edinburgh

December Talks + Rust Book Raffle

2022-12-01 | Wrocław, PL | Rust Wrocław

Rust Wrocław Meetup #30

2022-12-06 | London, UK | Rust London User Group

Go X Rust: A Very Scalable Christmas Party

2022-12-07 | Zurich, CH | Rust Zurich

Next generation i18n with rust (icu4x) and zero-copy deserialization

2022-12-12 | Enschede, NL | Dutch Rust Meetup

Rust Meetup - Subject TBA

2022-12-15 | Stuttgart, DE | Rust Community Stuttgart

OnSite Meeting

North America

2022-12-01 | Lehi, UT, US + Virtual | Utah Rust

Beginner Projects and Shop Talk with Food!

2022-12-08 | Columbus, OH, US | Columbus Rust Society

Monthly Meeting

2022-12-20 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

Oceania

2022-12-09 | Melbourne, VIC, AU | Rust Melbourne

December 2022 Meetup

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

After many years of writing bugs, and then discovering Rust, I learned to appreciate explicitness in code, and hope you eventually will too.

– Artem Borisovskiy on rust-users

Thanks to Árpád Goretity for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[bondadanagaraju]

BONDADA NAGARAJU: WEB ASSEMBLY AND ASSEMBLY SCRIPT

What if you could easily incorporate brilliant features from other programming languages into your JavaScript project? That is the overall concept of WebAssembly. Full-stack Developer Bondada Nagaraju teaches you about WebAssembly and AssemblyScript in Part 3 of our WebVR series, demonstrating how they may be used to create a browser-backend for web apps.

WebAssembly is not a replacement for JavaScript as the web's and the world's lingua franca.

[forcepusher]

Barging into Open-Source.

I’m pretty excited to start my open-source development career with a pull request into AssemblyScript* compiler.

https://github.com/AssemblyScript/assemblyscript/issues/1617 https://github.com/AssemblyScript/assemblyscript/pull/1618 (* a strict variant of TypeScript for WebAssembly).

[certainsuitkid]

What is AssemblyScript? https://ift.tt/3kdl5rv

[saibatudomt]

WebAssembly: passing array back and forth between JavaScript and AssemblyScript; The easy way

If you are getting started with WebAssembly (WASM) and need an easy way to pass arrays between JS and WASM generated using AssemblyScript: met As-Bind, an isomorphic library to handle passing high-level data structures between AssemblyScript and JavaScript, created by Aaron Turner (@torch2424).

Let’s start a new project, open an terminal cd into your development folder, create a new folder and cd…

[hackernewsrobot]

WebAssembly: TinyGo vs. Rust vs. AssemblyScript

https://ecostack.dev/posts/wasm-tinygo-vs-rust-vs-assemblyscript/ Comments

[mylittlegameplan]

Making a Little Game: A Review

During the month of April, I set out to make a game. My goal specifically was to make a game in about one month. It didn’t take me long at all to pick up on the basics of using the WASM-4 game engine. I feel accomplished with not only finishing my game, but the process I took while making it.

Lately, I have been trying to transition my career from that of an IT manager to a software developer, but I was having trouble finishing the projects I started. I knew that I needed to work on a project that would offer a quick result; I needed just a little win to get things moving.

I decided to work with a fantasy console. I love retro games and retro computing and fantasy consoles offer a very  accessible way to attain that aesthetic. A fantasy console is like an emulator for an old computer, but instead of emulating a real computer, it emulates a fictional idealized retro machine. You may have heard of other fantasy consoles like Pico-8 or TIC-80. However, it was the WASM-4 console that checked all my boxes:

Open-Source, this is a very important part of my development style.

Exports to Web, I wanted my game to be very accessible even from mobile devices.

Fantasy Console limitations, I liked the idea of being restricted to the style of a retro system.

You might ask why I would want to intentionally restrict my design? It makes the development process simpler, focused, and free of distractions. More flexible game engines have been confusing and distracting me lately. It’s easy to get overwhelmed by all the features and options they have, but a fantasy console makes it simple what I can and cannot do. It provides me with a limited tool set and lets me come up with the rest.

Working with WASM-4 was mostly straightforward. Getting it set up using NPM was easy. Learning AssemblyScript wasn’t too difficult for me, but I have had previous experience coding in JavaScript, C++, and other languages. I was, however, constantly going back and forth between the docs for WASM-4, AssemblyScript, and TypeScript because sometimes the problem with my code was in one system or it was deeper in another. I also enjoyed the flexibility of using the text editor of my choice (Atom) as opposed to other fantasy consoles that recommend or even require you use their in-system editor. I get how a custom editor in the same system can help with the immersion of the experience of working with an older computer, but I prefer to have the option of using an editor that I can customize to my preferences.

One of the other reasons I chose to go with WASM-4 over other fantasy consoles was the use of WebAssembly. I had been toying around with the idea of actually making a game for an older system. I wanted to learn about the process of working with a low-level language or even assembly language. However, I felt intimidated by the prospect of having to dig up decades-old references on how to program for these systems and deal with the quirks of a piece of hardware that had been out of support since my childhood (or older). WebAssembly shares the low-level style of working with an older system, but utilizes modern technology. Technology that is being used practically and developed on to this day. WebAssembly is a growing part of the infrastructure of the internet today and that was exciting to me.

I learned many things while working on this project. I brushed up on JS concepts that I had grown rusty on. I learned about bit manipulation in JS. I learned memory manipulation in AssemblyScript, including dynamic memory and garbage collection which caused me some concern near the end of my project. Lastly, I learned about myself and my working styles. Creating (almost) daily blog posts chronicling my development exploits helped me to reflect on what I had done that day. Ending the day with creating a to-do list for the next day helped me to pick up work more quickly at the start of the next day. Finding places that improved my productivity was also a learning experience.

I believe that creating this small game, Floppy Fish for the WASM-4, has been the kick start I needed to get moving on my game development career. I’m looking forward to working on bigger and better things; my next project is going to be made using the Godot game engine. Even so, I certainly will return to WASM-4 to work on other little retro projects especially if I find myself overwhelmed by the bigger industry again.

[wecodeinc]

What is WebAssembly (wasm) ?

WebAssembly is a new type of code that can be run in modern web browsers — it is a low-level assembly-like language with a compact binary format that runs with near-native performance and provides languages such as C/C++, C# and Rust with a compilation target so that they can run on the web.

WebAssembly is designed to complement and run alongside JavaScript — using the WebAssembly JavaScript APIs, you can load WebAssembly modules into a JavaScript app and share functionality between the two. This allows you to take advantage of WebAssembly’s performance and power and JavaScript’s expressiveness and flexibility in the same apps, even if you don’t know how to write WebAssembly code.

Now, if you have programs in C/C++ or Rust etc. now you can run those programs on the web with help of WebAssembly alongside JavaScript. You can also develop WebAssembly using AssemblyScript (A language made for WebAssembly).

Now these has opened doors for running complex programs written in ��low-level assembly-like language” on web.

We are already seeing some interesting use cases of WebAssembly, Like TensorFlow has announced — WebAssembly backend for TensorFlow.js (more details here)

One more interesting example of WebAssembly could be — A WebAssembly Powered Augmented Reality Sudoku Solver.

In our example using WebAssembly NES emulator and run Super Mario Brothers and Tetris game in our web browser.

TL;DR Use docker image:

$ docker pull bhargavshah86/rust-wasm-demo:1.0.0 $ docker run --name rust-wasm-demo -d -p 8080:80 bhargavshah86/rust-wasm-demo:1.0.0$ # http://localhost:8080/wasm_rust_demo.html

Manual steps:

Download WebAssembly NES emulator (nes_rust_wasm.js and nes_rust_wasm_bg.wasm)

Download ROM files,

Super_mario_brothers.nes

Tetris.nes

3. HTML and JS code to glue in all parts together

<html>  <head>    <meta content="text/html;charset=utf-8" http-equiv="Content-Type"/>    <style>    canvas {      background: #000;      margin: 10px;    }    .actual {      width: 256;      height: 240;    }    .double {      width: 512;      height: 480;    }    .quadruple {      width: 1024;      height: 960;    }    td {    padding: 5px; }    </style>  </head>  <body>    <script type="module">      import init, { WasmNes, Button } from './nes_rust_wasm.js';      const setupAudio = (wasm, nes) => {        const audioContext = AudioContext || webkitAudioContext;        if (audioContext === undefined) {          throw new Error('This browser seems not to support AudioContext.');        }        const bufferLength = 4096;        const context = new audioContext({sampleRate: 44100});        const scriptProcessor = context.createScriptProcessor(bufferLength, 0, 1);        scriptProcessor.onaudioprocess = e => {          const data = e.outputBuffer.getChannelData(0);          nes.update_sample_buffer(data);          // Adjust volume          for (let i = 0; i < data.length; i++) {            data[i] *= 0.25;          }        };        scriptProcessor.connect(context.destination);      };      const start = romArrayBuffer => {        // @TODO: Call init beforehand        init()          .then(wasm => run(wasm, new Uint8Array(romArrayBuffer)))          .catch(error => console.error(error));      };      const run = (wasm, romContentArray) => {        const width = 256;        const height = 240;        const canvas = document.getElementById('nesCanvas');        const ctx = canvas.getContext('2d');        const imageData = ctx.createImageData(width, height);        const pixels = new Uint8Array(imageData.data.buffer);        const nes = WasmNes.new();        nes.set_rom(romContentArray);        setupAudio(wasm, nes);        nes.bootup();        // FPS counter        let totalElapsedTime = 0.0;        let previousTime = performance.now();        let frameCount = 0;        const fpsSpan = document.getElementById('fpsSpan');        const countFps = () => {          frameCount++;          const currentTime = performance.now();          const elapsedTime = currentTime - previousTime;          totalElapsedTime += elapsedTime;          previousTime = currentTime;          if ((frameCount % 60) === 0) {            fpsSpan.textContent = (1000.0 / (totalElapsedTime / 60)).toFixed(2);            totalElapsedTime = 0.0;            frameCount = 0;          }        }        // animation frame loop        const stepFrame = () => {          requestAnimationFrame(stepFrame);          countFps();          nes.step_frame();          nes.update_pixels(pixels);          ctx.putImageData(imageData, 0, 0);        };        // joypad event listener setup        // @TODO: Mapping should be configurable        const getButton = keyCode => {          switch (keyCode) {            case 32: // space              return Button.Start;            case 37: // Left              return Button.Joypad1Left;            case 38: // Up              return Button.Joypad1Up;            case 39: // Right              return Button.Joypad1Right;            case 40: // Down              return Button.Joypad1Down;            case 50: // 2              return Button.Joypad2Down;            case 52: // 4              return Button.Joypad2Left;            case 54: // 6              return Button.Joypad2Right;            case 56: // 8              return Button.Joypad2Up;            case 65: // A              return Button.Joypad1A;            case 66: // B              return Button.Joypad1B;            case 82: // R              return Button.Reset;            case 83: // S              return Button.Select;            case 88: // X              return Button.Joypad2A;            case 90: // Z              return Button.Joypad2B;            default:              return null;          }        };        window.addEventListener('keydown', event => {          const button = getButton(event.keyCode);          if (button === null) {            return;          }          nes.press_button(button);          event.preventDefault();        }, false);        window.addEventListener('keyup', event => {          const button = getButton(event.keyCode);          if (button === null) {            return;          }          nes.release_button(button);          event.preventDefault();        }, false);        stepFrame();      };      // rom load      let romSelected = false;      document.getElementById('romSelect').addEventListener('change', event => {        if (romSelected) return;        romSelected = true;        const select = event.target;        const option = select.selectedOptions[0];        const filename = option.value;        if (!filename) {          return;        }        select.disabled = true; // @TODO: Reset Nes instead        fetch('./' + filename)          .then(result => result.arrayBuffer())          .then(start)          .catch(error => console.error(error));      });      window.addEventListener('dragover', event => {        event.preventDefault();      }, false);      window.addEventListener('drop', event => {        event.preventDefault();        if (romSelected) return;        romSelected = true;        document.getElementById('romSelect').disabled = true; // @TODO: Reset Nes instead        const reader = new FileReader();        reader.onload = e => {          start(e.target.result);        };        reader.onerror = e => {          console.error(e);        };        reader.readAsArrayBuffer(event.dataTransfer.files[0]);      }, false);      // screen size      document.getElementById('screenSizeSelect').addEventListener('change', event => {        const select = event.target;        const option = select.selectedOptions[0];        const className = option.value;        if (!className) {          return;        }        const canvas = document.getElementById('nesCanvas');        for (const name of ['actual', 'double', 'quadruple']) {          if (name === className) {            canvas.classList.add(name);          } else {            canvas.classList.remove(name);          }        }      });    </script>        <div>      <select id="romSelect">        <option value="" selected>-- select rom --</option>        <option value="Super_mario_brothers.nes">Super Mario</option>        <option value="Tetris.nes">Tetris</option>      </select>      or Drag and Drop your own rom file    </div>    <div>      <canvas id="nesCanvas" width="256" height="240"></canvas>    </div>    <div>      <select id="screenSizeSelect">        <option value="actual" selected>256x240</optioin>        <option value="double">512x480</optioin>        <option value="quadruple">1024x960</optioin>      </select>      <span id="fpsSpan">--.--</span> fps    </div>    <div>      <table>              <tr>          <td>Down →</td>          <td>Down</td>        </tr>        <tr>          <td>Left →</td>          <td>Left</td>        </tr>        <tr>          <td>Right →</td>          <td>Right</td>          <!-- <td>6</td> -->        </tr>        <tr>          <td>Up →</td>          <td>Up</td>          <!-- <td>8</td> -->        </tr>        <tr>          <td>A →</td>          <td>A</td>          <!-- <td>X</td> -->        </tr>        <tr>          <td>B →</td>          <td>B</td>          <!-- <td>Z</td> -->        </tr>        <tr>          <td>Start →</td>          <td>Space</td>          <!-- <td>-</td> -->        </tr>        <tr>          <td>Select →</td>          <td>S</td>          <!-- <td>-</td> -->        </tr>        <tr>          <td>Reset →</td>          <td>R</td>          <!-- <td>-</td> -->        </tr>      </table>    </div>    <div>      <p>NES Roms Copyright      <a href="https://github.com/takahirox/nes-rust">NES emulator in Rust</a></p>    </div>  </body> </html>

4. Open our “rust_wasm_demo.html” in browser.

Conclusion:

WebAssembly brings the performance of native applications to the web in a way that’s completely secure, yet enabling a full functionality expected from games, major applications and the entire spectrum of software you can run on a computer. WebAssembly is just built as a binary format and very compact to download, and also very efficient to compile and execute. There’s a whole bunch of optimizations coming that will drive that even further, allowing huge mobile applications to load up quickly, even on mobile devices.

Source:

[swagharmonywinner]

What is AssemblyScript? https://ift.tt/3kdl5rv https://ift.tt/2UgvLrq

[innosync]

Useful analysis of sharded general public chain Close to ecological DApp deployment and interaction logic

The logical geometry of creating a DApp on the shard public chain NEAR? Analyze the logic process behind DApp deployment and blockchain conversation with source program code practice. Original title: "Close to Application and Blockchain Interaction Analysis" Compiled by: Ni Sen NEAR is really a next-generation general public chain project that uses sharding to boost blockchain scalability and focuses on performance and user experience. It really is committed to providing a system that can market the large-scale usage of Dapp. This short article explores the logical process behind Dapp deployment and interaction with the blockchain by creating a sample project and combining source code analysis. Create a deployment Dapp 1st develop a simple Dapp. Environmental installation Before performing the next steps, make sure you have installed npm, node, near-shell, and develop tools such as for example gulp. Create project What's create-near-app create-near-app is really a template device used to quickly generate the basic framework of a project. It currently works with react templates and indigenous templates. Use create-near-app to produce a simple project framework myapp in today's directory: npx create-near-app --vanilla myapp The picture below shows a basic project that was successfully created. Among them, hide is responsible for storing main code, assembly can be used to shop contract code, and neardev can be used to store some accounts configurations. Create account and authorize Following the project is established, unless you have a NEAR account, first go to the wallet to create an account, and execute near login in the project directory to authorize the account based on the operation steps. At this time, the corresponding accounts file will be created in the neardev folder. Next, create a merchant account for the agreement: near create_accounts myappaccount --masterAccount=hashquark --initialBalance 2 Change the contract name in conceal/config.js to the name of the agreement you just created: Package and begin After installing dependencies and starting the project with npm install && npm start, you can go to the local port 5000 to open the web site. After logging in to the wallet and completing the authorization, it will come back to the home page to display the welcome consumer (as proven in the amount below). Process analysis The following will combine source code analysis to explore the process logic of the above steps. Contract compilation What's wasm WebAssembly, also called wasm, is an experimental low-end programming language applied to your client in the internet browser. Wasmer is a wasm runtime atmosphere in addition to the internet browser. NEAR's smart agreement virtual machine is implemented predicated on wasmer, and its own smart contract also needs to be compiled right into a wasm file. NEAR smart agreements currently support composing in AssemblyScript or Rust. When building the project, the smart agreement will eventually be compiled into a wasm file and kept in the out directory. You can view the related logic in the gulp configuration file: Contract deployment NEAR tool introduction ChainLink near-shell is a command series tool used to interact with the near protocol, based on nearlib. nearlib is a Javascript SDK that interacts with the near protocol. Once you execute npm begin to begin the project, it will first execute close to deploy to deploy the contract. The near deploy command is a near-shell order. The main code is demonstrated below: As you can see, near deploy executes nearlib's deployContract method through the account under the neardev folder, which calls signAndSendTransaction to send the transaction for deploying the agreement:  It isn't difficult to note that the core of the deployment contract would be to construct the transaction with agreement data, indication it with the account, and then send the signed deal to the node. Sending a deal essentially encodes the info and sends a JsonRpc request with a method named "broadcast_tx_commit" to the node. The decision relationship diagram of contract deployment is as follows: Next, how will the node handle JsonRpc requests? Node processing deployment request What is nearcore nearcore can be an official node execution of the near protocol, written in Corrosion. The execution of nearcore uses the actix framework for concurrent and asynchronous digesting. Actix will be ??an Actor-based concurrency design that exchanges information for parallel processing through message passing. When the nearcore node starts, it will begin an http service to process the RPC request of the node; ViewClientActor, ClientActor and PeerManagerActor are also started at the same time to respond to different events: As is seen from the body below, the http assistance mainly makes use of JsonRpcHandler to procedure each request. The primary processing functions of JsonRpcHandler are as follows, when we get a request with a method named "broadcast_tx_commit", we will call the send_tx_commit solution to process:

The core of the send_tx_commit method would be to send a NetworkClientMessages message of the Transaction type to the ClientActor to which it really is bound. In ClientActor, you can see that the message is processed by process_tx: In the course of action_tx method, it'll first check if the transaction is one of the shard it is in: If so, check the validity of the transaction and determine whether you're an active validator, and when it isn't a dynamic validator, you may be handled by another validator. If not, it'll be handled by other nodes. After that, the transactions in the memory pool will undoubtedly be stored on the blockchain through consensus, in order that our contract may also exist on the blockchain. The aforementioned process can refer to the next diagram: The contract calls the view method Following the smart contract is deployed, what goes on when the contract technique is called? Contract view technique and change method The methods of the NEAR smart contract could be split into the view method and the change method. The watch method does not change the state of the blockchain, as the change technique is the opposite, so user authorization is normally required. In myapp/primary.js, the nearlib technique will be called first to produce a reference to the close to node and instantiate the contract technique. In the myapp task, the view technique you want to call will be specified when instantiating-welcome. When instantiating the contract, utilize the loadContract method to generate a contract object: When generating the agreement object, bind the accounts, contract title and specific interface through the structure method: Then, within the processing function right after login, the welcome method defined in the contract is named, and the effect is displayed in the page. When the welcome method is called, the viewFunction bound at instantiation is executed. It can be seen that calling the welcome approach to the contract essentially sends a JsonRpc request with the technique name "query" to the node, the parameter path is "call/$contractId/$methodName", and data may be the methodName parameter. The aforementioned process can refer to the following figure: Node processing watch method Like the aforementioned near processing "broadcast_tx_commit", processing the "query" RPC request will call the query approach to JsonRpcHandler. The core of the query method is to send a Query message to the ViewClientActor bound by JsonRpcHandler for processing. The core of ViewClientActor's processing of Query messages: first query the fragment information where the query content is situated, if that's the case, call its own query (including calling the virtual machine execution method, etc.), or even, path it to additional nodes for processing. The above process can refer to the next diagram: Summary This article analyzes how the Dapp initiates a demand and how the Close to node processes the request through the procedure by creating, deploying, and invoking a straightforward NEAR smart agreement. I am hoping that by elaborating on this process, it could be enlightened to visitors and NEAR technology enthusiasts.

[iamprogrammerz]

Getting Started with AssemblyScript ☞ http://bit.ly/32r0ZO1 #AssemblyScript #WebAssembly #Morioh

[kazupon-blog]

2017 IN REVIEW

いつもの感じで、2017年振り返ってみました。

GitHub の草 (contributions)

2017年の草はこんな感じになりました。2016年の草も比較のために載せておきます。

2017 GitHub contributions

2016 GitHub contributions

contributions は今年は 4151 で、去年は 3505。

去年と同じく、Vue.js の OSS によるレビューや公式ドキュメント、awesome-vue のメンテなどによる活動がほとんど。後は、Storybook とか、個人の vue-i18n といった感じでしょう。

今年は去年より増えていますが、OSS の方では、そんなにガリガリコード書いてコミットし��ないので、業務で新規開発プロジェクトがあったからその開発コミット数で膨らんでいるんという感じでしょうか。

イベントでの発表

今年の発表は以下の 5 件 でした。

Vue.js vue build

イベント: DIST.14 「事例で見るVue.jsとJavaScript LT」

Vue.js Single File Components++

イベント: Meguro.es x Gotanda.js #1 in Drecom

Vue on Storybook

イベント: Node学園 26時限目

Vue.js Extend with Compiler

イベント: ToKyoto.js ― Kyoto.js in Tokyo

Future of Vue.js

イベント: Vue.js Tokyo v-meetup #6

去年と比べると落ち着いた感じです。去年のふりかりで断言したとおり控えることができました。

イベント主催

自分、Vue.js 日本ユーザーグループの organaizer ですが、今年は以下の Meetup イベント 4 件開催しました。

Vue.js Tokyo v-meetup="#3" (参加申し込み数: 251)

Vue.js Tokyo v-meetup #4 (参加申し込み数: 294)

Vue.js Tokyo v-meetup #5 (参加申し込み数: 243)

Vue.js Tokyo v-meetup #6 (参加申し込み数: 270)

去年は2件だったのに、今年は4件。先日のブログで書いたとおり、これは完全 Vue.js 人気の余波です。参加申し込み人数が常に200人オーバーで、募集開始から1時間もかからないうちに定員達する人気ぶり。

去年まで初期メンバーのVue.js 日本ユーザーグループスタッフと私で運営していましたので、この規模になるとフルスタックでは手に負えなくなったので、途中から新規に運営メンバーを募集して今はイベント当日は12〜15名ぐらいで運営できるようになって大分楽になった感じです。100名規模が集まるMeetupイベントの運営を支えれるようになったのは、スタッフの皆さんのおかげなので大変感謝です🙏 。

OSS 活動

去年に引き続き、 Vue.js のコアチームメンバーとして活動しています。主に以下の活動をしました。

vuejs/jp.vuejs.org: Vue.js 日本語公式ドキュメントの翻訳メンテ

vuejs/vue-ssr-docs: Vue.js サーバサイドレンダリングのドキュメント翻訳とメンテ

vuejs/awesome-vue: Vue.js 関連のライブラリやエコシステムの素晴らしいリスト

その他の以下レポジトリのドキュメント翻訳メンテ

vuejs/vue-router

vuejs/vuex

vuejs/vue-loader

vuejs/vue-test-utils

去年は Vue 2.0 のリリースのために、Vue コアの単体テストといったドキュメント以外に実装にもコミットできていたんですけど、今年はドキュメントのコミットとなった感じです。

vuejs/vue-ssr-docs は新規ドキュメントの翻訳だったので大変だったので、Vue 2.0 のドキュメント翻訳と同様に、Vue.js コミュニティの力と、GitLocalizeの力を借りてやりました。

中でも、GitLocalizeはホント助かりました。翻訳の一番大変なのは、原文の更新の追跡なので、GitLocalizeで追跡して検出してくれるのは大変助かりました。GitLocalizeの中の人には大変感謝です。

今回の翻訳では、GitLocalize を利用させて頂きました。GitLocalize にも大変感謝です！https://t.co/2yaQv2qxoY

— 🐤kazuya kawaguchi🐤 (@kazu_pon) 2017年7月11日

vuejs/jp.vuejs.org のドキュメントメンテは、コミュニティの方が参加してくれるようになったので、去年とくらべて楽になりました。中でも、re-fort さんの che-tsumi という bot の投入は、GitHub Issues で翻訳内容が Issue という形でチケット化され、そしてそのまま取り込めるものは Pull Request にしてくれるようになったので、大分運用負荷と管理が低減されるようになりました。日本の Vue.js コミュニティには大変感謝です🙇。

他に、Vue.js 関連で自分がメンテしているものとして、vue-i18n と vue-validator を持っているのですが、これらについても活動しています。

多言語化ライブラリの vue-i18n については、以下のメジャーリリースをしています。

6.0.0

7.0.0

そして、ここ直近の 7.3.0 のリリースでは、パフォーマンスを最大化できるように対応しましたが、この時このリリース対応の内容がどんなものであるかどうか分かってもらえるよう、初めて英語でブログ記事書きました。普段ブログもそんなに書かないの上、さらに英語なので大変でしたが、書いてみて意外と英語で書けるもんなんだなあと実感しました。海外の人に読みやすいものかどうか分かりませんが。

vue-validator については、去年Vue.js公式から取り下げてからメンテできていないのと、今後 i18n にフォーカスしていきたいため、残念がらつい最近開発を停止することを決意し、リポジトリを archive しました。

I archived vue-validator ✅ repository, due to I'll focus to vue-i18n 🌐 maintanance and new ideas of i18n architechture for WebAssembly. Thank you for everything you have done for vue-validator. /cc @vuejs https://t.co/MhNTZrqpGx

— 🐤kazuya kawaguchi🐤 (@kazu_pon) 2017年12月25日

最後に、Vue.js 以外の OSS 活動に取り組みとして、Storybook で Vue をサポートするために、メンバーに加わって活動しました。

つい先日のブログ記事にも書きましたが、Storybook はコンポーネントといったUI開発環境を提供するツール的なものですが、React.js、Raact Native といった React 関連ののみしかサポートしていませんでした。同様なものとして、vue-playがありますが、作者のegoist氏が vue-play に対して活動がアクティブではおらず、Storybook と同等のものが利用できる状態ではありませんでした。

そんな中、Storybook で Vue.js をサポートするために Storybook のメンバーといっしょに自分も開発を進めてリリースできたことは、大変エキサイティングであったし、Vue.js コミュニティが Storybook を使って効率的なコンポーネント開発を可能になるのは、開発体験(DX: Development Experience)がよくなるので、ホントよかったと思っています。また、Storybook のチームメンバとして参加することによって、他の OSS の文化を体験することができてよかったと思っています。

ポッドキャスト

2017 年は初めてポッドキャストに出演した。しかも、いきなり 5 件も。

genba.fm: #1 Awesome Vue

soussune: 28. コアコミッターが語るVue.jsの話

soussune: 32. Vueでワイワイやっていき

soussune: 33. Vueでワイワイやっていき Aftershow

しがないラジオ: sp.9a【ゲスト: kazu_pon】楽しい廃人格闘ゲーマーがWeb系CTOになるまで

しがないラジオ: sp.9b【ゲスト: kazu_pon】楽しいOSSコアチームメンバーへの道

ポッドキャストは中々難しいですね。話すシナリオは予め show notes などで考えているんですが、実際にはパーソナリティと対話形式みたいな感じで進めていくので、リスナーのみなさんを意識した喋る必要がありますので。

来年はもう少しリスナーに聴きやすい話し方にしていきたいところです。

仕事関係

今年も引き続き、CTO として会社のシステム全般をリードしながら開発しつつ、CFO 的な会社の予算計画やキャッシュフロー周りをみながらやっていますが、今年は採用周りの人事もやっています。

開発は、今年は新規プロジェクトが立ち上がり無事終えて、次回に向けて進めることができてよかったのですが、それに伴い開発力を強化するためにエンジニアが必要になってきています。今年は自分の目標としては新しい仲間を増やしたかったのですが、現時点の結果としては採用できていないので、なぜ採用できなかったのか、いろいろと反省してみて、引き続き新しい仲間と共にいっしょにやっていけるようにしたいところです。

来年度にむけて (まとめ)

今年も、OSS の方は去年に引き続き Vue.js コアチームとして OSS 活動し、他に Storybook のメンバーとして OSS 活動しました。

イベントの方は新たに加わったスタッフと共にいっしょにやることで定期的に開催し、役割分担することで運営することができました。

仕事の方は、引き続き CTO & 開発、経営企画しながら、さらに人事周りの経験してきました。

来年度ですが、OSS の方は、Vue.js のミッションに向けて引き続きコアチーム、そして Storybook のメンバーとして OSS 活動していきますが、翻訳以外に OSS 開発する時間を増やしていきたいと考えています。

具体的には、WebAssembly 時代を想定した i18n の新しいアーキテクチャのプロトタイプを実装していきたいと考えています。

WebAssembly の方は今年主要ブラウザでサポ���トするようになり、それに伴い AssemblyScript にような WebAssembly をサポートするような言語も出現しつつあります���また、WebAssembly は GC などの次に向けた仕様や、Web 以外での動作も想定した仕様が策定されつつあります。

これまで、vue-i18n を通して多言語化ライブラリを作成してきましたが、そのライブラリ開発や ECMA-402 の仕様、そしてこの"i18n ライブラリ、フレームワークは新しい todo apps?"という記事"にもある通り、特定のプログラミング言語や、ライブラリ、フレームワークに依存しない、i18n のアーキテクチャを考えて仕組みを提供したいと思うようになりました。

WebAssembly の将来性を考えると、i18n はまさにユースケースにピッタリだと考えています。

来年度は、WebAssembly 関係の技術をウォッチしつつ、i18n の新しいアーキテクチャの PoC をやっていきたいところです。

イベントの方は、日本で Vue.js カンファレンス開催に向けて、スタッフといっしょに頑張ります！💪

仕事の方は、何としてでも新しい仲間といっしょにやっていきたいところです。

それでは、皆様、良いお年を。来年もよろしくお願いいたします。