#wasm and its use case | Explore Tumblr posts and blogs

this-week-in-rust · 1 year ago

Text

This Week in Rust 541

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 and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

Announcing Rust 1.77.1

Changes to u128/i128 layout in 1.77 and 1.78

Newsletters

This Week In Bevy: 2d Lighting, Particle Systems, Meshlets, and more

Project/Tooling Updates

Dioxus 0.5: Signal Rewrite, Remove lifetimes, CSS Hotreloading, and more!

EtherCrab 0.4.0: Pure Rust EtherCAT, now with Distributed Clocks

nethsm 0.1.0 - first release for this high level library for the Nitrokey NetHSM

BugStalker v0.1.3 released - first release of rust debugger

git-cliff 2.2.0 is released! (highly customizable changelog generator)

Observations/Thoughts

On Reusing Arc and Rc in Rust

Who killed the network switch?

Xr0 Makes C Safer than Rust

Easy Mode Rust

Bashing Bevy To Bait Internet Strangers Into Improving My Code

Conway's Game of Life Through Time

Functions Everywhere, Only Once: Writing Functions for the Everywhere Computer

Rust Bytes: Is Rust the Future of JavaScript Tooling?

Explaining the internals of async-task from the ground up

Programming ESP32 with Rust: OTA firmware update

Fast Development In Rust, Part 2

Rust Walkthroughs

Modelling Universal Domain Types in Rust

[video] developerlife.com - Get started with unit testing in Rust

Research

Rust Digger: More than 14% of crates configure rustfmt. 35 Have both rustfmt.toml and .rustfmt.toml

Miscellaneous

Building a Managed Postgres Service in Rust: Part 1

Beware of the DashMap deadlock

Embedded Rust Bluetooth on ESP: BLE Client

Rust Unit and Integration Testing in RustRover

[podcast] cargo-semver-checks with Predrag Gruevski — Rustacean Station

[video] Data Types - Part 3 of Idiomatic Rust in Simple Steps

[video] Deconstructing WebAssembly Components by Ryan Levick @ Wasm I/O 2024

[video] Extreme Clippy for new Rust crates

[video] [playlist] Bevy GameDev Meetup #2 - March 2024

Building Stock Market Engine from scratch in Rust (I)

Crate of the Week

This week's crate is cargo-unfmt, a formatter that formats your code into block-justified text, which sacrifices some readability for esthetics.

Thanks to Felix Prasanna for the self-suggestion!

Please submit your suggestions and votes for next week!

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 calls for testing were issued 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.

Call for Participation; projects and speakers

CFP - Projects

Always wanted to contribute to open-source projects but did not 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.

greptimedb - Support specifying time ranges in the COPY FROM statement to avoid importing unwanted data

greptimedb - Support converting UNIX epoch numbers to specified timezone in to_timezone function

mirrord - Capability to modify the local listen address

mirrord - Fix all check-rust-docs warnings

Hyperswitch - [REFACTOR]: Remove Default Case Handling - Braintree

Hyperswitch - [REFACTOR]: Remove Default Case Handling - Fiserv

Hyperswitch - [REFACTOR]: Remove Default Case Handling - Globepay

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

CFP - Speakers

Are you a new or experienced speaker looking for a place to share something cool? This section highlights events that are being planned and are accepting submissions to join their event as a speaker.

If you are an event organizer hoping to expand the reach of your event, please submit a link to the submission website through a PR to TWiR.

Updates from the Rust Project

431 pull requests were merged in the last week

CFI: (actually) check that methods are object-safe before projecting their receivers to dyn Trait in CFI

CFI: abstract Closures and Coroutines

CFI: fix drop and drop_in_place

CFI: fix methods as function pointer cast

CFI: support calling methods on supertraits

add a CurrentGcx type to let the deadlock handler access TyCtxt

add basic trait impls for f16 and f128

add detection of (Partial)Ord methods in the ambiguous_wide_pointer_comparisons lint

add rust-lldb pretty printing for Path and PathBuf

assert that ADTs have the right number of args

codegen const panic messages as function calls

coverage: re-enable UnreachablePropagation for coverage builds

delegation: fix ICE on wrong Self instantiation

delegation: fix ICE on wrong self resolution

do not attempt to write ty::Err on binding that isn't from current HIR Owner

don't check match scrutinee of postfix match for unused parens

don't inherit codegen attrs from parent static

eagerly instantiate closure/coroutine-like bounds with placeholders to deal with binders correctly

eliminate UbChecks for non-standard libraries

ensure std is prepared for cross-targets

fix diagnostics for async block cloning

fixup parsing of rustc_never_type_options attribute

function ABI is irrelevant for reachability

improve example on inserting to a sorted vector to avoid shifting equal elements

in ConstructCoroutineInClosureShim, pass receiver by mut ref, not mut pointer

load missing type of impl associated constant from trait definition

make TyCtxt::coroutine_layout take coroutine's kind parameter

match ergonomics 2024: implement mutable by-reference bindings

match lowering: build the Place instead of keeping a PlaceBuilder around

match lowering: consistently merge simple or-patterns

match lowering: handle or-patterns one layer at a time

match lowering: sort Eq candidates in the failure case too

pattern analysis: Require enum indices to be contiguous

replace regions in const canonical vars' types with 'static in next-solver canonicalizer

require Debug for Pointee::Metadata

require DerefMut and DerefPure on deref!() patterns when appropriate

rework opaque type region inference

simplify proc macro bridge state

simplify trim-paths feature by merging all debuginfo options together

store segment and module in UnresolvedImportError

suggest associated type bounds on problematic associated equality bounds

suggest correct path in include_bytes!

use the Align type when parsing alignment attributes

warn against implementing Freeze

enable cargo miri test doctests

miri: avoid mutating the global environment

miri: cotrol stacked borrows consistency check with its own feature flag

miri: experiment with macOS M1 runners

miri: extern-so: give the version script a better name; show errors from failing to build the C lib

miri: speed up Windows CI

miri: tree Borrows: Make tree root always be initialized

don't emit load metadata in debug mode

avoid some unnecessary query invocations

stop doing expensive work in opt_suggest_box_span eagerly

stabilize ptr.is_aligned, move ptr.is_aligned_to to a new feature gate

stabilize unchecked_{add,sub,mul}

make {integer}::from_str_radix constant

optimize core::char::CaseMappingIter

implement Vec::pop_if

remove len argument from RawVec::reserve_for_push

less generic code for Vec allocations

UnixStream: override read_buf

num::NonZero::get can be 1 transmute instead of 2

fix error message for env! when env var is not valid Unicode

futures: make access inner of futures::io::{BufReader,BufWriter} not require inner trait bound

regex-syntax: accept {,n} as an equivalent to {0,n}

cargo add: Preserve comments when updating simple deps

cargo generate-lockfile: hold lock before querying index

cargo toml: Warn on unused workspace.dependencies keys on virtual workspaces

cargo fix: bash completion fallback in nounset mode

clippy: large_stack_frames: print total size and largest component

clippy: type_id_on_box: lint on any Box<dyn _>

clippy: accept String in span_lint* functions directly to avoid unnecessary clones

clippy: allow filter_map_identity when the closure is typed

clippy: allow manual_unwrap_or_default in const function

clippy: don't emit duplicated_attribute lint on "complex" cfgs

clippy: elide unit variables linted by let_unit and use () directly instead

clippy: fix manual_unwrap_or_default suggestion ignoring side-effects

clippy: fix suggestion for len_zero with macros

clippy: make sure checked type implements Try trait when linting question_mark

clippy: move box_default to style, do not suggest turbofishes

clippy: move mixed_attributes_style to style

clippy: new lint legacy_numeric_constants

clippy: restrict manual_clamp to const case, bring it out of nursery

rust-analyzer: add rust-analyzer.cargo.allTargets to configure passing --all-targets to cargo invocations

rust-analyzer: implement resolving and lowering of Lifetimes (no inference yet)

rust-analyzer: fix crate IDs when multiple workspaces are loaded

rust-analyzer: ADT hover considering only type or const len not lifetimes

rust-analyzer: check for client support of relative glob patterns before using them

rust-analyzer: lifetime length are not added in count of params in highlight

rust-analyzer: revert debug extension priorities

rust-analyzer: silence mismatches involving unresolved projections

rust-analyzer: use lldb when debugging with C++ extension on MacOS

rust-analyzer: pattern analysis: Use contiguous indices for enum variants

rust-analyzer: prompt the user to reload the window when enabling test explorer

rust-analyzer: resolve tests per file instead of per crate in test explorer

Rust Compiler Performance Triage

A pretty quiet week, with most changes (dropped from the report below) being due to continuing bimodality in the performance data. No particularly notable changes landed.

Triage done by @simulacrum. Revision range: 73476d49..3d5528c

1 Regressions, 2 Improvements, 5 Mixed; 0 of them in rollups 61 artifact comparisons made in total

Full report here

Approved RFCs

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

Merge RFC 3543: patchable-function-entry

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

No RFCs entered Final Comment Period this week.

Tracking Issues & PRs

Rust

[disposition: merge] Pass list of defineable opaque types into canonical queries

[disposition: merge] Document overrides of clone_from() in core/std

[disposition: merge] Tracking Issue for Seek::seek_relative

[disposition: merge] Tracking Issue for generic NonZero

[disposition: merge] Tracking Issue for cstr_count_bytes

[disposition: merge] privacy: Stabilize lint unnameable_types

[disposition: merge] Stabilize Wasm target features that are in phase 4 and 5

Cargo

[disposition: merge] feat(add): Stabilize MSRV-aware version req selection

New and Updated RFCs

[new] RFC: Add freeze intrinsic and related library functions

[new] RFC: Add a special TryFrom and Into derive macro, specifically for C-Style enums

[new] re-organise the compiler team

Upcoming Events

Rusty Events between 2024-04-03 - 2024-05-01 🦀

Virtual

2024-04-03 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Rust for Rustaceans Book Club: Chapter 4 - Error Handling

2024-04-03 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2024-04-04 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-04-09 | Virtual (Dallas, TX, US) | Dallas Rust

BlueR: a Rust Based Tool for Robust and Safe Bluetooth Control

2024-04-11 | Virtual + In Person (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-04-11 | Virtual (Nürnberg, DE) | Rust Nüremberg

Rust Nürnberg online

2024-04-15 & 2024-04-16 | Virtual | Mainmatter

Remote Workshop: Testing for Rust projects – going beyond the basics

2024-04-16 | Virtual (Dublin, IE) | Rust Dublin

A reverse proxy with Tower and Hyperv1

2024-04-16 | Virtual (Washinigton, DC, US) | Rust DC

Mid-month Rustful

2024-04-17 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2024-04-18 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-04-25 | Virtual + In Person (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-04-30 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2024-05-01 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

Africa

2024-04-05 | Kampala, UG | Rust Circle Kampala

Rust Circle Meetup

Europe

2024-04-10 | Cambridge, UK | Cambridge Rust Meetup

Rust Meetup Reboot 3

2024-04-10 | Cologne/Köln, DE | Rust Cologne

This Month in Rust, April

2024-04-10 | Manchester, UK | Rust Manchester

Rust Manchester April 2024

2024-04-10 | Oslo, NO | Rust Oslo

Rust Hack'n'Learn at Kampen Bistro

2024-04-11 | Bordeaux, FR | Rust Bordeaux

Rust Bordeaux #2 : Présentations

2024-04-11 | Reading, UK | Reading Rust Workshop

Reading Rust Meetup at Browns

2024-04-15 | Zagreb, HR | impl Zagreb for Rust

Rust Meetup 2024/04: Building cargo projects with NIX

2024-04-16 | Bratislava, SK | Bratislava Rust Meetup Group

Rust Meetup by Sonalake #5

2024-04-16 | Leipzig, DE | Rust - Modern Systems Programming in Leipzig

winnow/nom

2024-04-16 | Munich, DE + Virtual | Rust Munich

Rust Munich 2024 / 1 - hybrid

2024-04-17 | Bergen, NO | Hubbel kodeklubb

Lær Rust med Conways Game of Life

2024-04-20 | Augsburg, DE | Augsburger Linux-Infotag 2024

Augsburger Linux-Infotag 2024: Workshop Einstieg in Embedded Rust mit dem Raspberry Pico WH

2024-04-23 | Berlin, DE | Rust Berlin

Rust'n'Tell - Rust for the Web

2024-04-25 | Aarhus, DK | Rust Aarhus

Talk Night at MFT Energy

2024-04-25 | Berlin, DE | Rust Berlin

Rust and Tell

2024-04-27 | Basel, CH | Rust Basel

Fullstack Rust - Workshop #2

North America

2024-04-04 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2024-04-04 | Portland, OR, US | PDXRust Meetup

Hack Night and First Post-Pandemic Meetup Restart

2024-04-09 | New York, NY, US | Rust NYC

Rust NYC Monthly Meetup

2024-04-10 | Boulder, CO, US | Boulder Rust Meetup

Rust Meetup: Better Builds w/ Flox + Hangs

2024-04-11 | Seattle, WA, US | Seattle Rust User Group

Seattle Rust User Group Meetup

2024-04-11 | Spokane, WA, US | Spokane Rust

Monthly Meetup: Topic TBD!

2024-04-15 | Somerville, MA, US | Boston Rust Meetup

Davis Square Rust Lunch, Apr 15

2024-04-16 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2024-04-16 | Seattle, WA, US | Seattle Rust User Group

Seattle Rust User Group: Meet Servo and Robius Open Source Projects

2024-04-18 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2024-04-24 | Austin, TX, US | Rust ATX

Rust Lunch - Fareground

2024-04-25 | Nashville, TN, US | Music City Rust Developers

Music City Rust Developers - Async Rust on Embedded

2024-04-26 | Boston, MA, US | Boston Rust Meetup

North End Rust Lunch, Apr 26

Oceania

2024-04-30 | Canberra, ACT, AU | Canberra Rust User Group

April 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

Panstromek: I remember reading somewhere (probably here) that borrow checking has O(n^3) asymptotic complexity, relative to the size of the function.

Nadrieril: Compared to match exhaustiveness which is NP-hard and trait solving which is undecidable, a polynomial complexity feels refreshingly sane.

– Panstromek and Nadrieril on zulip

Thanks to Kevin Reid 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

#rust-lang #rust #rustlang #twir #long post

2 notes · View notes

hawkstack · 3 months ago

Text

Service Mesh with Istio and Linkerd: A Practical Overview

As microservices architectures continue to dominate modern application development, managing service-to-service communication has become increasingly complex. Service meshes have emerged as a solution to address these complexities — offering enhanced security, observability, and traffic management between services.

Two of the most popular service mesh solutions today are Istio and Linkerd. In this blog post, we'll explore what a service mesh is, why it's important, and how Istio and Linkerd compare in real-world use cases.

What is a Service Mesh?

A service mesh is a dedicated infrastructure layer that controls communication between services in a distributed application. Instead of hardcoding service-to-service communication logic (like retries, failovers, and security policies) into your application code, a service mesh handles these concerns externally.

Key features typically provided by a service mesh include:

Traffic management: Fine-grained control over service traffic (routing, load balancing, fault injection)

Observability: Metrics, logs, and traces that give insights into service behavior

Security: Encryption, authentication, and authorization between services (often using mutual TLS)

Reliability: Retries, timeouts, and circuit breaking to improve service resilience

Why Do You Need a Service Mesh?

As applications grow more complex, maintaining reliable and secure communication between services becomes critical. A service mesh abstracts this complexity, allowing teams to:

Deploy features faster without worrying about cross-service communication challenges

Increase application reliability and uptime

Gain full visibility into service behavior without modifying application code

Enforce security policies consistently across the environment

Introducing Istio

Istio is one of the most feature-rich service meshes available today. Originally developed by Google, IBM, and Lyft, Istio offers deep integration with Kubernetes but can also support hybrid cloud environments.

Key Features of Istio:

Advanced traffic management: Canary deployments, A/B testing, traffic shifting

Comprehensive security: Mutual TLS, policy enforcement, and RBAC (Role-Based Access Control)

Extensive observability: Integrates with Prometheus, Grafana, Jaeger, and Kiali for metrics and tracing

Extensibility: Supports custom plugins through WebAssembly (Wasm)

Ingress/Egress gateways: Manage inbound and outbound traffic effectively

Pros of Istio:

Rich feature set suitable for complex enterprise use cases

Strong integration with Kubernetes and cloud-native ecosystems

Active community and broad industry adoption

Cons of Istio:

Can be resource-heavy and complex to set up and manage

Steeper learning curve compared to lighter service meshes

Introducing Linkerd

Linkerd is often considered the original service mesh and is known for its simplicity, performance, and focus on the core essentials.

Key Features of Linkerd:

Lightweight and fast: Designed to be resource-efficient

Simple setup: Easy to install, configure, and operate

Security-first: Automatic mutual TLS between services

Observability out of the box: Includes metrics, tap (live traffic inspection), and dashboards

Kubernetes-native: Deeply integrated with Kubernetes

Pros of Linkerd:

Minimal operational complexity

Lower resource usage

Easier learning curve for teams starting with service mesh

High performance and low latency

Cons of Linkerd:

Fewer advanced traffic management features compared to Istio

Less customizable for complex use cases

Choosing the Right Service Mesh

Choosing between Istio and Linkerd largely depends on your needs:

Choose Istio if you require advanced traffic management, complex security policies, and extensive customization — typically in larger, enterprise-grade environments.

Choose Linkerd if you value simplicity, low overhead, and rapid deployment — especially in smaller teams or organizations where ease of use is critical.

Ultimately, both Istio and Linkerd are excellent choices — it’s about finding the best fit for your application landscape and operational capabilities.

Final Thoughts

Service meshes are no longer just "nice to have" for microservices — they are increasingly a necessity for ensuring resilience, security, and observability at scale. Whether you pick Istio for its powerful feature set or Linkerd for its lightweight design, implementing a service mesh can greatly enhance your service architecture.

Stay tuned — in upcoming posts, we'll dive deeper into setting up Istio and Linkerd with hands-on labs and real-world use cases!

Would you also like me to include a hands-on quickstart guide (like "how to install Istio and Linkerd on a local Kubernetes cluster")? 🚀

For more details www.hawkstack.com

#hawkstack #hawkstack technologies #kubernetes #redhat #ansible #automation #openshift

0 notes

dzinesoniya · 4 months ago

Text

Understanding WebAssembly: A Quiet Revolution in Web Performance

When we think of building websites, we often think of HTML, CSS, and JavaScript. These three have been the backbone of the web for a long time. But as websites and apps grow more complex, developers need something faster and more powerful—especially for performance-heavy tasks. That’s where WebAssembly (Wasm) steps in.

Let’s break down what it is and why it’s getting attention across the tech world, without getting too technical.

What is WebAssembly?

WebAssembly is a code format that runs in the browser. It’s not meant to replace JavaScript but to work alongside it. Think of it as a faster way to run code that needs speed—like gaming, video editing, data processing, or even parts of e-commerce sites with lots of user activity.

What makes WebAssembly special is its ability to run at near-native speed, meaning it can perform heavy tasks much faster than traditional JavaScript in many cases. Developers can write code in languages like C, C++, or Rust and compile it into WebAssembly, which then runs in the browser.

Why Should You Care?

Speed. That’s the big reason. In today’s world, users expect websites to load quickly and respond instantly. If you’re building a platform with lots of real-time features—say, a live video platform, a product configurator, or a browser-based game—JavaScript alone might not cut it.

Here’s what WebAssembly can do better:

Load faster, especially for complex tasks

Use memory more efficiently

Deliver smooth experiences for graphic-heavy or real-time apps

For businesses, that means happier users, lower bounce rates, and more time spent on the site.

What Does This Mean for Website Owners?

While WebAssembly is still new for many, it's gradually finding its way into real projects—especially where performance really matters.

If you're running a basic blog or business site, you probably won’t need WebAssembly right away. But if your web app handles large files, video processing, or needs real-time interactions, this technology can make a big difference.

And here’s the important part: not every team is ready to implement it correctly. That’s where working with an experienced website designing company in India can help. These companies are often at the front of using better tech to make websites run smoother and load faster—especially for demanding industries like fintech, healthcare, or eCommerce.

Real-World Examples

Some well-known platforms have already started using WebAssembly in clever ways:

Figma, a popular design tool, uses WebAssembly to speed up rendering and real-time collaboration in the browser.

AutoCAD Web App relies on it to bring a full CAD experience to users without installing software.

Online games that run smoothly inside the browser also benefit from it.

These use cases show that you don’t always need a native app to offer high performance. A smart setup in the browser is enough.

The Role of Your Development Partner

If you're thinking of building a web app where performance is critical, choosing the right team matters. A skilled website designing company in India will know when and where to apply WebAssembly. They won’t just throw in trendy tools for the sake of it—but use them to genuinely improve performance.

They’ll help you identify if your site or app can benefit from this technology, and how to introduce it without causing problems elsewhere.

#best web development agencies india #website design and development company in india #website development company in india #web design company india #website designing company in india #digital marketing agency india

0 notes

govindhtech · 9 months ago

Text

Service Extensions Plugins For Application Load Balancers

An overview

Service Extensions plugins are a new functionality that Google Cloud has added to its Application Load Balancers. With the help of these plugins, users can run custom code directly within the load balancer’s request and response paths, increasing the programmability of web application delivery. Because the plugins are based on WebAssembly (Wasm), they offer features like secure sandboxing, compatibility for several programming languages, and quick execution speeds. Use cases for this new functionality are varied and include HTML rewriting, custom logging, security policy implementation, and header manipulation. Scalability and low latency are provided by the completely managed environment in which users can operate the plugins.

Now use the Application Load Balancers to execute your own code at the edge.

For dependable online application delivery on Google Cloud, application load balancers are necessary. Although Google Cloud’s load balancers allow for a great deal of customization, there are some circumstances that call for even more programmability.

Google Cloud just revealed the Application Load Balancer Service Extensions plugins in Preview. To adapt load balancers to your business needs, you can now run your custom code right in the request/response path in a fully controlled Google environment with optimal latency. Just supply the code, and Google Cloud takes care of the rest. You can look to Service Extensions callouts, which are presently GA for Application Load Balancers if you want to handle the computation yourself for heavier workloads.

Service Extensions plugins use cases

The following use cases are supported by Service Extensions plugins:

Header addition: Include additional headers for requests and responses, or make new headers pertinent to your apps or particular clients.

Header manipulation: Rewriting request and response headers or overriding client headers while they are being sent to the backend or while replying to a client are examples of header manipulation.

Security: Create sophisticated security rules, such as custom token authentication, depending on response headers or client requests, and decide how to apply them within your plugin.

Custom logging: Enter custom data or user-defined headers into Cloud Logging.

Exception handling: For specific response types, send customers to a personalized error page.

HTML Rewriting: To enable Google Analytics tagging or Google reCAPTCHA integration, rewrite HTML from its original source.

Where your code can be executed

Service Extensions operate at the edge of Google’s widely dispersed network, in the request and response channel. The current traffic extension for the global external Application Load Balancer now includes Service Extensions plugins. The traffic extension executes prior to traffic reaching the backend, but after Cloud CDN and Cloud Armor. Service Extensions will be supported by cloud CDNs in a later edition. Additionally, as part of the route and traffic extensions, the cross-region internal load balancer supports Service Extensions plugins.

Architecture of Service Extension Plugins

Lightweight computation tasks that are part of the Application Load Balancer request/response flow are the focus of Service Extensions plugins. WebAssembly (Wasm), on which plugins are built, has the following advantages:

Startup time in milliseconds and near-native execution speed

Numerous programming languages, including C++ and Rust, are supported.

Cross-platform portability allows you to test the plugin locally or run it across many installations.

Protections for security, including running plugin logic in a sandbox

Service Extensions Plugins make use of Proxy-Wasm, an open source project backed by Google that offers Wasm modules a common API for interacting with network proxies.

Google developed a computing platform that is both scalable and massively multi-tenant (similar to load balancers) to execute Service Extensions plugins. Fully managed plugins offer auto-scaling and dynamic sharding to accommodate traffic demands. This design makes it possible for:

Scalability: As traffic patterns change, we can expand to a large number of Wasm hosts as needed.

Low latency: This proxyless serverless architecture enables even more latency-optimal pathways because there are no extra proxies between the load balancer and Wasm hosts.

Read more on Govindhtech.com

#ServiceExtensions #ServiceExtensionsplugins #LoadBalancers #CloudCDN #API #Cloudcomputing #News #Technews #Technology #Technologynews #Technologytrends #Govindhtech

0 notes

mirandamckenni1 · 2 years ago

Text

youtube

WebAssembly's Status in Computing Liam Crilly, Senior Director of Product Management at @nginx_official, discussed the potential of WebAssembly (Wasm) during this recording at the Open Source Summit in Bilbao, Spain. With over three decades of experience, Crilly highlighted WebAssembly's promise of universal portability, allowing developers to build once and run anywhere across a network of devices. While Wasm is more mature on the client side in browsers, its deployment on the server side is less developed, lacking sufficient runtimes and toolchains. Crilly noted that WebAssembly acts as a powerful compiler target, enabling the generation of well-optimized instruction set code. Despite the need for a virtual machine, WebAssembly's abstraction layer eliminates hardware-specific concerns, providing near-native compute performance through additional layers of optimization. Learn more from The New Stack about WebAssembly and NGINX: WebAssembly Overview, News and Trends https://ift.tt/9sYC1hX Why WebAssembly Will Disrupt the Operating System https://ift.tt/1KWafwc True Portability Is the Killer Use Case for WebAssembly https://ift.tt/wJoVIxk 4 Factors of a WebAssembly Native World https://ift.tt/z5daWJ0 via YouTube https://www.youtube.com/watch?v=7TJKwdkE1jM

#IFTTT #YouTube #Youtube

0 notes

ailtrahq · 2 years ago

Text

The Relay Chain lies at the core of the Polkadot ecosystem, functioning as the primary Blockchain of the network. It helps to Safeguard overall network integrity and facilitate communication among parachains. Parachains stand as parallel blockchains that represent the various Layer-1 projects building in the Polkadot ecosystem. They serve as hosts for Decentralized Applications and various Blockchain-driven projects. The versatility of parachains lies in their adaptability to cater to the specific requirements of the hosted projects. For instance, a parachain designated for a decentralized exchange could be configured to manage a high volume of transactions efficiently. Parachains such as the Astar Network also incorporate features such as Ethereum Virtual Machine (EVM) compatibility, WebAssembly (WASM) smart contracts and cross-consensus messaging (XCM) to facilitate seamless communication between Decentralized Applications (DApps). On the other hand, bridges serve as vital conduits connecting the Polkadot network to other Blockchain networks. The overarching goal of bridges is to enhance the interoperability of disparate Blockchain networks so they can communicate and interact effectively. To better illustrate how they work, consider the scenario where a developer seeks to construct an application harnessing data from two incompatible blockchains. Such an endeavor would be untenable without a bridge system, given the inherent incompatibility between them. In such a case, Polkadot acts as an enabler, facilitating communication and data sharing between the two disparate blockchains. A real-world use case would involve a user aiming to transfer Assets across different blockchains. Without a solution like the XCM messaging format, which allows blockchains to interact, such an operation would necessitate reliance on a centralized exchange. Networks like Polkadot allow users to migrate Assets between blockchains directly, eliminating the need for third-party intermediaries. Another unique property of the Polkadot network is that it operates as a layer-0 Blockchain. A layer-0 Blockchain serves as a foundational framework upon which subsequent blockchains can be constructed. As a layer-0 Blockchain, it provides infrastructure that empowers programmers to fashion their own blockchains while ensuring cross-chain interoperability. As such, blockchains developed atop the Polkadot platform can seamlessly communicate and engage with one another, regardless of technological variations. This is a substantial advantage over conventional blockchains, which frequently exist in isolated silos, incapable of mutual communication. It makes the Polkadot network ideal for crafting Decentralized Applications utilizing data from multiple blockchains. As Polkadot is already established as the foundational layer, it alleviates many of the problems programmers face when working with rigid layer-1 chains by providing a more adaptable base infrastructure. Governance of the Polkadot network is carried out directly by holders of the DOT token, whereby token holders actively participate in a voting process to vote on all proposals aimed at making changes to the network. The democratic approach, launched earlier this year and known as OpenGov, grants every token holder a voice in shaping the platform’s evolution. When it comes to transaction validation, Polkadot employs a nominated proof-of-stake (NPoS) mechanism to select its validator set, focusing on enhancing chain Security. Validator nodes are responsible for block production, parachain block validation, and finality assurance, while nominators can support specific validators with their stake, backing trusted candidates with their tokens. window.fbAsyncInit = function () FB.init( appId: '1922752334671725', xfbml: true, version: 'v2.9' ); FB.AppEvents.logPageView(); ; (function (d, s, id) var js, fjs = d.getElementsByTagName(s)[0]; if (d.getElementById(id)) return; js = d.createElement(s);

js.id = id; js.src = " js.defer = true; fjs.parentNode.insertBefore(js, fjs); (document, 'script', 'facebook-jssdk')); !function (f, b, e, v, n, t, s) if (f.fbq) return; n = f.fbq = function () n.callMethod ? n.callMethod.apply(n, arguments) : n.queue.push(arguments) ; if (!f._fbq) f._fbq = n; n.push = n; n.loaded = !0; n.version = '2.0'; n.queue = []; t = b.createElement(e); t.defer = !0; t.src = v; s = b.getElementsByTagName(e)[0]; s.parentNode.insertBefore(t, s) (window, document, 'script', ' fbq('init', '1922752334671725'); fbq('track', 'PageView');

0 notes

dromologue · 2 years ago

Text

0 notes

codetribesolutions · 2 years ago

Text

What is the future: Web or Mobile App Development?

The future of web and mobile app development will continue to play crucial roles in the digital landscape. Each has its strengths and is suited for different use cases and user preferences. Here's how the future might look for both:

Web Development:

Progressive Web Apps (PWAs): PWAs are web applications that offer a native app-like experience with features like offline functionality, push notifications, and fast loading times. They bridge the gap between web and app experiences.

Responsive Design: As mobile devices with various screen sizes and resolutions continue to emerge, responsive design will remain important. Websites that adapt seamlessly to different devices will continue to be a priority.

Web Assembly (Wasm): Web Assembly allows running high-performance applications on the web, enabling complex tasks that were traditionally reserved for native apps. This will contribute to richer web experiences.

Voice and Visual Search: The web will continue to incorporate voice search and visual search technologies, enhancing user interactions and providing new avenues for businesses to engage with customers.

Cross-Platform Compatibility: Developing for the web offers cross-platform compatibility by default. As more devices and platforms come into play, the web's versatility will be a significant advantage.

SEO and Discoverability: Websites remain discoverable through search engines, and strong SEO practices are crucial for online visibility. This is particularly important for businesses looking to attract organic traffic.

Mobile App Development:

Enhanced User Experiences: Mobile apps provide a more tailored and immersive user experience compared to web browsers. Apps will continue to evolve to deliver smooth interactions and personalised content.

Augmented Reality (AR) and Virtual Reality (VR): Mobile apps will integrate AR and VR experiences, enabling interactive and engaging content for users in various sectors, from gaming to education to e-commerce.

App Store Optimisation (ASO): As app stores continue to host millions of apps, app store optimisation will be essential for improving app visibility and driving downloads.

Mobile Payment Integration: Mobile apps will further integrate payment gateways and streamline the checkout process, making mobile shopping and transactions more convenient for users.

Offline Functionality: Mobile apps can provide offline functionality, allowing users to access certain features even without an internet connection. This can be especially valuable in regions with limited connectivity.

Native Performance: Native apps often offer better performance, as they can leverage the device's hardware more efficiently. This will remain relevant for apps that require high performance.

In conclusion, both web and mobile app development will continue to evolve and complement each other. The choice between the two depends on factors like your target audience, business goals, user experience requirements, and the specific functionalities you need to provide. Many companies opt for a hybrid approach, where they have a responsive website and a mobile app, ensuring a strong online presence across different platforms. The key is to assess your needs and choose the development approach that aligns best with your strategy and user expectations.

#mobile application development #software development services #web developers #webdesigner #mobile app company #mobile app development #custom mobile app development #custom mobile application development

0 notes

this-week-in-rust · 1 year ago

Text

This Week in Rust 543

This Week in Rust is openly developed on GitHub and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Rust Nation UK

Tim McNamara - 4 levels of error handling

Mithun Hunsur - Ambient: A Rust and WebAssembly Runtime for Cross-Platform Multiplayer Games

Alice Ryhl - What it takes to keep Tokio running

Chris Biscardi - Bevy: A case study in ergonomic Rust

Pietro Albini - How Ferrocene qualified the Rust Compiler

Ben Wishovich - Full Stack Rust - Building Rust Websites with Leptos

Natalie Serebryakova - Rustic Persistence: Automating PVC Lifecycles with Rust in Kubernetes

Daniel McKenna - Creating a Text-To-Speech System in Rust

Konstantin Grechishchev - Java and Rust Integration

Heiko Seeberger - EventSourced – async_fn_in_trait in anger

Tim Janus - Let's get interdisciplinary: Rust Design Patterns for Chemical Plants

Marco Ieni - How Rust makes open-source easier

Newsletters

New Meshes, New Examples, and Compute Shaders

Project/Tooling Updates

futures-concurrency v7.6.0: Portable Concurrent Async Iteration

Ratatui v0.26.2

Rust on Espressif chips

Introducing Dust DDS – A native Rust implementation of the Data Distribution Service (DDS) middleware

Announcing the first audited Rust implementation of CGGMP21, the state-of-the-art ECDSA threshold protocol

Nutype 0.4.2 - newtype with guarantees

venndb 0.2.1 - any filters

[ZH|EN] Announcing async-openai-wasm, and thoughts on wasmization and streams

Observations/Thoughts

Climbing a (binary) Tree - Noise On The Net

Why is there no realloc that takes the number of bytes to copy?

Some useful types for database-using Rust web apps

My logging recipe for server side Rust

Rust Walkthroughs

Getting started with SurrealDB using Docker and a Rust client

[video] developerlife.com - Rust testing deep dive with r3bl_terminal_async crate

Research

Rust Digger: 7.53% of crates have both 'edition' and 'rust-version', 11.21% have neither

Miscellaneous

Iced Tutorial 0.12

[video] Infinite Pong in the Bevy Game Engine - Let's Code!

[audio] Release-plz with Marco Ieni

Crate of the Week

This week's crate is venndb, an append-only memory DB whose tables can be build via a derive macro.

Thanks to Glen De Cauwsemaecker for the self-suggestion!

Please submit your suggestions and votes for next week!

Call for Testing

No calls for testing were issued this week.

Call for Participation; projects and speakers

CFP - Projects

Always wanted to contribute to open-source projects but did not 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.

mirrord - medschool generated malformed JSON

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

CFP - Speakers

Are you a new or experienced speaker looking for a place to share something cool? This section highlights events that are being planned and are accepting submissions to join their event as a speaker.

RustConf 2024 | Closes 2024-04-25 | Montreal, Canada | Event date: 2024-09-10

RustLab 2024 | Closes 2024-05-01 | Florence, Italy | Event date: 2024-11-09 - 2024-11-11

EuroRust 2024| Closes 2024-06-03 | Vienna, Austria & online | Event date: 2024-10-10

Scientific Computing in Rust 2024| Closes 2024-06-14 | online | Event date: 2024-07-17 - 2024-07-19

Conf42 Rustlang 2024 | Closes 2024-07-22 | online | Event date: 2024-08-22

RustConf 2024 | Closes 2024-04-25 | Montreal, Canada | Event date: 2024-09-10

If you are an event organizer hoping to expand the reach of your event, please submit a link to the submission website through a PR to TWiR.

Updates from the Rust Project

430 pull requests were merged in the last week

add support for Arm64EC inline assembly (as unstable)

statx probe: ENOSYS might come from a faulty FUSE driver

account for trait/impl difference when suggesting changing argument from ref to mut ref

add REDUNDANT_LIFETIMES lint to detect lifetimes which are semantically redundant

add unsafe to two functions with safety invariants

add const generics support for pattern types

add support to intrinsics fallback body

async closure coroutine by move body MirPass refactoring

avoid a panic in set_output_capture in the default panic handler

be more specific when flagging imports as redundant due to the extern prelude

call lower_const_param instead of duplicating the code

call the panic hook for non-unwind panics in proc-macros

detect borrow checker errors where .clone() would be an appropriate user action

disable Ctrl-C handling on WASM

discard overflow obligations in impl_may_apply

do not add prolog for variadic naked functions

do not allocate for ZST ThinBox (attempt 2 using const_allocate)

don't delay a bug if we suggest adding a semicolon to the RHS of an assign operator

don't do coroutine-closure-specific upvar analysis if tainted by errors

don't even parse an intrinsic unless the feature gate is enabled

don't leak unnameable types in -> _ recover

don't rely on upvars being assigned just because coroutine-closure kind is assigned

fix UB in LLVM FFI when passing zero or >1 bundle

fix invalid silencing of parsing error

fix various bugs in ty_kind_suggestion

generic associated consts: Check regions earlier when comparing impl with trait item def

improve diagnostic by suggesting to remove visibility qualifier

just use type_dependent_def_id to figure out what the method is for an expr

linker flavors next steps: linker features

linker: avoid some allocations in search directory iteration

linker: remove laziness and caching from native search directory walks

make PlaceRef and OperandValue::Ref share a common PlaceValue type

make the computation of coroutine_captures_by_ref_ty more sophisticated

only assert for child/parent projection compatibility AFTER checking that theyre coming from the same place

only collect mono items from reachable blocks

openBSD fix long socket addresses

panic on overflow in BorrowedCursor::advance

propagate temporary lifetime extension into if and match

provide suggestion to dereference closure tail if appropriate

refactor panic_unwind/seh.rs pointer use

remove From impls for unstable types that break inference

rework ptr-to-ref conversion suggestion for method calls

set target-abi module flag for RISC-V targets

skip unused_parens report for Paren(Path(..)) in macro

stop making any assumption about the projections applied to the upvars in the ByMoveBody pass

stop using HirId for fn-like parents since closures are not OwnerNodes

stop using PolyTraitRef for closure/coroutine predicates already instantiated w placeholders

store all args in the unsupported Command implementation

suppress let else suggestion for uninitialized refutable lets

tweak value suggestions in borrowck and hir_analysis

typeck: fix ? suggestion span

use fn ptr signature instead of {closure@..} in infer error

use suggest_impl_trait in return type suggestion on type error

miri: MIRI_REPLACE_LIBRS_IF_NOT_TEST: also apply to crates.io crates

miri: add some basic support for GetFullPathNameW

miri: fix error display for './miri run --dep'

miri: handle Miri sysroot entirely outside the Miri driver

miri: make split_simd_to_128bit_chunks take only one operand

miri on Windows: run .CRT$XLB linker section on thread-end

miri: windows: add basic support for FormatMessageW

stabilize --json unused-externs(-silent)

stabilize (const_)slice_ptr_len and (const_)slice_ptr_is_empty_nonnull

stabilize cstr_count_bytes

implement FromIterator for (impl Default + Extend, impl Default + Extend)

re-enable has_thread_local for i686-msvc

std::net: TcpListener shrinks the backlog argument to 32 for Haiku

show mode_t as octal in std::fs Debug impls

add A: 'static bound for Arc/Rc::pin_in

f16 and f128 step 4: basic library support

add a Debug impl and some basic functions to f16 and f128

specialize many implementations of Read::read_buf_exact

windows: set main thread name without re-encoding

cargo: make sure to also wrap the initial -vV invocation

cargo resolve: Respect '--ignore-rust-version'

cargo resolve: Fallback to 'rustc -V' for MSRV resolving

cargo fix: dont apply same suggestion twice

cargo package: Normalize paths in Cargo.toml

cargo test: don't compress test registry crates

rustdoc: correctly handle inlining of doc hidden foreign items

rustdoc: check redundant explicit links with correct itemid

rustdoc: point at span in include_str!-ed md file

rustdoc: reduce per-page HTML overhead

clippy: module_name_repetition Recognize common prepositions

clippy: fix: incorrect suggestions when .then and .then_some is used

clippy: pin remark-lint-maximum-line-length version

clippy: turn duplicated_attributes into a late lint

clippy: use check_attributes in doc lints

rust-analyzer: add static and const highlighting token types

rust-analyzer: better inline preview for postfix completion

rust-analyzer: wrap/Unwrap cfg_attr

rust-analyzer: VFS should not confuse paths with source roots that have the same prefix

rust-analyzer: fix impl Trait<Self> causing stack overflows

rust-analyzer: fix inlay hint resolution being broken

rust-analyzer: fix: support auto-closing for triple backticks

rust-analyzer: run cargo test per workspace in the test explorer

Rust Compiler Performance Triage

A quiet week, with slightly more improvements than regressions. There were a few noise spikes, but other than that nothing too interesting.

Triage done by @Kobzol. Revision range: 86b603cd..ccfcd950b

Summary:

(instructions:u) mean range count Regressions ❌ (primary) 0.5% [0.3%, 1.4%] 9 Regressions ❌ (secondary) 0.4% [0.2%, 1.1%] 20 Improvements ✅ (primary) -0.6% [-2.5%, -0.2%] 41 Improvements ✅ (secondary) -0.8% [-1.4%, -0.2%] 4 All ❌✅ (primary) -0.4% [-2.5%, 1.4%] 50

1 Regressions, 3 Improvements, 6 Mixed; 5 of them in rollups 62 artifact comparisons made in total

Full report here

Approved RFCs

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

No RFCs were approved this week.

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] Move the Crates.io Team under the Dev Tools team

[disposition: merge] Arbitrary self types v2

[disposition: merge] RFC: Syntax for embedding cargo-script manifests

[disposition: merge] rust-lang org GitHub access policy

Tracking Issues & PRs

Rust

[disposition: merge] Enforce closure args + return type are WF

[disposition: merge] Tracking Issue for io_error_downcast

[disposition: merge] More DefineOpaqueTypes::Yes

[disposition: merge] Tracking Issue for std::path::absolute

[disposition: merge] Tracking Issue for utf8_chunks

[disposition: merge] restrict promotion of const fn calls

[disposition: merge] Fix trait solver overflow with non_local_definitions lint

[disposition: merge] Use fulfillment in method probe, not evaluation

[disposition: merge] rustdoc-search: single result for items with multiple paths

[disposition: merge] Ignore -C strip on MSVC

New and Updated RFCs

No New or Updated RFCs were created this week.

Upcoming Events

Rusty Events between 2024-04-17 - 2024-05-15 🦀

Virtual

2024-04-17 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Reflections on RustNation UK 2024

2024-04-17 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Camigo (Peter Kehl)

2024-04-18 | Virtual (Charlottesville, VA, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-04-21 | Virtual (Israel) | Rust in Israel

Using AstroNvim for Rust development (in Hebrew)

2024-04-23 | Trondheim, NO | Rust Trondheim

Show and Tell in April

2024-04-24 | Virtual + In Person (Prague, CZ) | Rust Czech Republic

#2: Making Safe Rust Safer (Pavel Šimerda)

2024-04-25 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-04-30 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2024-05-01 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Rust for Rustaceans Book Club: Chapter 5 - Project Structure

2024-05-01 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2024-05-02 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-05-07 | Virtual (Buffalo, NY) | Buffalo Rust Meetup

Buffalo Rust User Group

2024-05-09 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup

2024-05-09 | Virtual (Israel) | Rust in Israel

Rust at Microsoft, Tel Aviv - Are we embedded yet?

2024-05-09 | Virtual (Nuremberg/Nürnberg, DE) | Rust Nuremberg

Rust Nürnberg online

2024-05-14| Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2024-05-14 | Virtual + In-Person (München/Munich, DE) | Rust Munich

Rust Munich 2024 / 1 - hybrid (Rescheduled)

2024-05-15 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

Africa

2024-05-04 | Kampala, UG | Rust Circle Kampala

Rust Circle Meetup

Asia

2024-04-20 | Kuala Lumpur, MY | GoLang Malaysia

Rust Talk & Workshop - Parallel Programming April 2024 | Event updates Telegram | Event group chat

2024-05-11 | Bangalore, IN | Rust Bangalore

May 2024 Rustacean meetup

Europe

2024-04-17 | Bergen, NO | Hubbel kodeklubb

Lær Rust med Conways Game of Life

2024-04-17 | Lyon, FR | Rust Lyon

Rust Lyon Meetup #10

2024-04-17 | Ostrava, CZ | TechMeetup Ostrava

TechMeetup: RUST

2024-04-20 | Augsburg, DE | Augsburger Linux-Infotag 2024

Augsburger Linux-Infotag 2024: Workshop Einstieg in Embedded Rust mit dem Raspberry Pico WH

2024-04-23 | Berlin, DE | Rust Berlin

Rust'n'Tell - Rust for the Web

2024-04-23 | Paris, FR | Rust Paris

Paris Rust Meetup #67

2024-04-24 | Virtual + In Person (Prague, CZ) | Rust Czech Republic

#2: Making Safe Rust Safer (Pavel Šimerda)

2024-04-25 | Aarhus, DK | Rust Aarhus

Talk Night at MFT Energy

2024-04-25 | Berlin, DE | Rust Berlin

Rust and Tell - TBD

2024-04-25 | København/Copenhagen, DK | Copenhagen Rust Community

Rust meetup #46 sponsored by Nine A/S

2024-04-25 | Vienna, AT | Rust Vienna

Rust Vienna x Python User Group - April

2024-04-27 | Basel, CH | Rust Basel

Fullstack Rust - Workshop #2 (Register by 23 April)

2024-04-27 | Stockholm, SE | Stockholm Rust

Ferris' Fika Forum #2

2024-04-30 | Budapest, HU | Budapest Rust Meetup Group

Rust Meetup Budapest 2

2024-04-30 | Salzburg, AT | Rust Salzburg

[Rust Salzburg meetup]: 6:30pm - CCC Salzburg, 1. OG, ArgeKultur, Ulrike-Gschwandtner-Straße 5, 5020 Salzburg

2024-05-01 | Utrecht, NL | NL-RSE Community

NL-RSE RUST meetup

2024-05-06 | Delft, NL | GOSIM

GOSIM Europe 2024

2024-05-07 & 2024-05-08 | Delft, NL | RustNL

RustNL 2024

2024-05-09 | Gdańsk, PL | Rust Gdansk

Rust Gdansk Meetup #2

2024-05-14 | Virtual + In-Person (München/Munich, DE) | Rust Munich

Rust Munich 2024 / 1 - hybrid (Rescheduled)

North America

2024-04-18 | Chicago, IL, US | Deep Dish Rust

Rust Talk: What Are Panics?

2024-04-18 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2024-04-24 | Austin, TX, US | Rust ATX

Rust Lunch - Fareground

2024-04-25 | Nashville, TN, US | Music City Rust Developers

Music City Rust Developers - Async Rust on Embedded

2024-04-26 | Boston, MA, US | Boston Rust Meetup

North End Rust Lunch, Apr 26

2024-05-04 | Cambridge, MA, US | Boston Rust Meetup

Kendall Rust Lunch, May 4

2024-05-12 | Brookline, MA, US | Boston Rust Meetup

Coolidge Corner Brookline Rust Lunch, May 12

Oceania

2024-04-17 | Sydney, NSW, AU | Rust Sydney

WMaTIR 2024 Gala & Talks

2024-04-30 | Auckland, NZ | Rust AKL

Rust AKL: Why Rust? Convince Me!

2024-04-30 | Canberra, ACT, AU | Canberra Rust User Group

CRUG April Meetup: Generics and Traits

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

There is absolutely no way I can imagine that Option is causing that error. That'd be like turning on the "Hide Taskbar" setting causing your GPU to catch fire.

[...]

If it's not any of those, consider an exorcist because your machine might be haunted.

– Daniel Keep on rust-users

Thanks to Hayden Brown 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

#rust-lang #rust #rustlang #twir #long post

1 note · View note

mentalisttraceur-software · 3 years ago

Text

An aimless rambly post about in-browser Pythons, with the approximate theme of:

I think I'd recommend PyScript at least as much as Brython for quick practical Python-in-the-browser web development if you don't really need to optimize performance.

PyScript is much more "heavy" since the underlying Pyodide is a full compile of CPython to WebAssembly, plus libraries, one of which gives it a built-in ability to download modules from PyPI from within the Python running in your browser. The heaviness and slow load time used to annoy me, but it buys you much more compatibility and certainty of compatibility with CPython.

The killer feature for me is being able to just import most packages that you might want to use without any of the hassle of "how do I get this into the browser?". Just `await micropip.install(foo)` in your browser-side Python code before `import foo` and you're good to go. Python has always been the language you reach for, first and foremost, when you strongly prefer to optimize for developer time+work instead of computer time+work, or when you want a great ability to tinker or modify code in situ. And doing something resembling "pip install" in the browser is very much a good example of that.

Right now, if you wanted to use one of my Python modules on Brython and you didn't know where to start, I'd have to write several sentences - grab the source, put it over there, maybe run the right brython-cli command to bundle it. If you want to use one of my Python modules on PyScript, you just grab it from PyPI with micropip and it just works (barring some edge cases which I recently helped them fix, which is in micropip v0.2.0 already and should be coming to Pyodide in v0.22).

One thing I liked about Brython is that it ships with some quality-of-life improvements for manipulating the DOM through its `browser` module, which tries to provide some ergonomics that you can't get in JavaScript for lack of operator overloads and the like. But PyScript has a good enough FFI to JavaScript that we can just start with the DOM manipulation that we would do in JavaScript, and then code whatever Python ergonomics we want around it (which could then just be uploaded to PyPI).

I also have mixed feelings about how PyScript gets all over the HTML namespaces - tags like `<py-script>` and `<py-config>`, attributes on HTML elements like `py-onclick` or whatever, that kind of thing. It's adding complication/coupling/non-orthogonality to buy a little developer experience friendliness. It feels fine now but I expect it'll prove clunky and annoying over time in various little ways - although to be fair, that's a problem that in part requires browsers and web standards to solve, and once that's standardized it shouldn't be too hard to migrate.

PyScript load times and download size can be pretty bad, but they're working on it. Admittedly an inherently hard problem, but I still think in the long term that gets solved out-of-band. Anecdotally, comparing the Brython website's demo REPL and the Pyodide (which PyScript uses) website's demo REPL, Brython loads perceptibly faster. But I haven't done any hard thorough measurements for real-world websites. For example, Brython lets you build a .js file with just the modules you're using, while the REPL on their website includes the whole standard library just in case. I'm not sure what PyScript's story is for that, but the out-of-band solutions are obvious and similar - bundlers and so forth.

Thing is, if you're really angling for performant Python-in-browser, you either transpile Python to JavaScript (something like Transcrypt, trading some semantic/feature consistency for speed), or you compile your Python to WebAssembly (conceptually something like Cython+Emscripten, but I haven't tried it or looked into how to actually do it) - and if you do that last thing, well incidentally you can upload that as yet another pre-compiled WASM wheel to PyPI which can then be used with PyScript too. And that looks a lot like the modern Python world where CPython speed is fine and if it isn't you compile the hot path Python code into native code.

Just like the Python of old, it will be one of the slower languages on the block for a while. Longer start up or page load times, more memory usage, more overheads all over the place just in case you're using the dynamic flexibility at execution time. That's fine. Humanity used Python twenty years ago, and it was fast enough for many uses. Today I think PyScript is in a similar boat. It will be slow, at first. That's fine. People will use it when they need to go fast, when the productivity or expressiveness or flexibility benefits of Python matter more than the fact that the page took a little while longer to load. Especially since you might be writing a web page that gets opened once and then stays open for hours or days on the user's computer.

Slowly but surely the automatic optimizations will catch up, and in the meantime, PyScript seems like the best contender for the cases where you want Python, not almost-Python but really Python, in the browser.

#web development #brython #pyscript #transcrypt #python #software #pythons in web browsers

19 notes · View notes

youknowwhosarmy · 5 years ago

Text

Mid-crash bawling

hey so i have absolutely no one to talk to about this

so im just going to rant a bit about something that happened to me today

i live on a border city, that is, mexican-United States border

i live on the mexican side, but i travel to and from several times a month

usually, there are three tolls and one lane before and after crossing

so because those three tolls merge into one single lane, common sense would say that we move forward one by one: one from the left toll, one from the middle one, and then one from the right lane

but this wasnt the case this time

the center and right lane were attempting to follow this rule, but the left lane wasn’t letting us, they were trying to follow their lane back to back

and then this other old ass dude in a truck from the left lane tried to get in front of me

fact about me #1: i have some anger issues, i am feisty, and i almost always try to make things go right

so i stayed put, basically glued to the back of the car from the center lane

but this asshole was doing the same

so the dude

has the fucking audacity

to fucking break my fucking side mirror

and i know for a fact he did in on purpose

fact about me #2: i cry. a lot. about everything. yes, everything

so in my mind i was thinking “i should fucking put this car on park, get out, and calmly explain to this guy that hey, thats not right and civilly come to an agreement because, again, hey, you broke my car, or at least a part of it

but by the time my brain came to this conclusion (which, mind you, did not take long at all, maybe 2 seconds) two things were already happening

one, the line was moving, so we were no longer on the U.S. side of the bridge, we were on the Mexican side

two, i was crying. and not even discreetly any more, i was full on bawling

i look through my review mirror and there wasm Mr. douchebag laughing hiss ass off because he made a fucking kid cry!!!

dude was easily 3 times my age, laughing at the fact that my dumb ass couldnt react the way i was supposed to

and oh my gosh

i am so pissed off

at him, mainly

because what kind of asshole just decides to fucking crash into me because they are doing the wrong thing?! and it wouldnt even make a difference, its just one car in front of you and secondly, at myself

because i let this dumbass get the better of me

because if i had just let him go first, this wouldnt have happened

because i have never learned to actually calm myself down, and that would have at least getten the justice my dear daisy deserves (thats my cars name btw, please dont judge)

because i realize that there are so many things wrong in this world, with us humans: that there is not enough justice, even for small things like this; that there are people out there who live for making others feel miserable and hurting them

i cried for maybe two hours straight

because i really cannot believe

just how far people will go defending their own wrong decisions, even when they are petty and inconsequential, such as waiting your turn to get in line

and i might be asked “if it was so inconsequential, if it was just one car and it did not make a difference, why couldn't you just let him go first?

so let me answer that

because it was my turn, it was my right to go

i should not have to give up my turn, my right, just because someone else feels like taking it from me

and i am a strong believer in that

whatever the case might be, i should not have to “give in” or “be the bigger person” when i am in the right mind just to avoid a problem or an issue, just because some asshole thinks they can get away with tormenting me

and maybe i should have, because then my car would not have suffered, maybe i would just be angry at him for going first, not angry because he broke my mirror and felt super proud of himself for it

so congratulations, Mr. I-made-a-20-year-old-child-in-a-corolla-cry, you have only increased my conviction and strengthened my belief that we should fight for what is right, and should not give in to bullies and their pride

#rant

3 notes · View notes