#Multithreading experimental | Explore Tumblr posts and blogs

this-week-in-rust · 2 years ago

Text

This Week in Rust 523

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

Project/Tooling Updates

Announcing axum 0.7.0

Announcing general availability of the AWS SDK for Rust

ripgrep 14.0.0

Improved Multithreading in wgpu - Arcanization Lands on Trunk

Introducing SALT: A Rust error tutor, seeking participants in a study of errors!

Bionic GPT - Chat GPT replacement built in Rust

cargo-run-bin: Why does everyone install crates globally?

CXX-Qt: On the Road to Stability, improved signals support and more in release 0.6

Oatmeal: Terminal UI to chat with large language models (LLM) using different model backends, and integrations with your favourite editors!

Observations/Thoughts

Project Goals

poll_next

[video] but what is 'a lifetime?

[audio] Recruiting in Rust with Cedric Sellmann

Rust Walkthroughs

Designing a SIMD Algorithm from Scratch

Why Enums in Rust feel so much better

How I Use Declarative Macros in Rust

Embassy on ESP: Getting Started

Intro to LLVM and MLIR with Rust and Melior

Rust Course (Part 2) - YouTube (Bahasa Indonesia).

Investigating crazy compile times

Research

Refinement Proofs in Rust Using Ghost Locks

Semantic fuzzing of the Rust compiler and interpreter

Miscellaneous

Read arbitrary YAML files in Rust

Create a Lambda in Rust using Terraform

Crate of the Week

This week's crate is tokio-graceful, a library for graceful shutdown of tokio-based async servers.

Thanks to Glen De Cauwsemaecker for the suggestion!

Please submit your suggestions and votes for next week!

Call for Participation

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.

* Hyperswitch - [REFACTOR]: [Nuvei] MCA metadata validation * Hyperswitch - [Features]: [Noon] Sync with Hyperswitch Reference * Hyperswitch - [Features]: [Payme] Sync with Hyperswitch Reference * Hyperswitch - [BUG]: MCA metadata deserialization failures should be 4xx * Hyperswitch - [REFACTOR]: [Stripe] Error Message For Connector Implementation * Ockam - Library - Slim down the NodeManagerWorker for node / node status * Ockam - Command - refactor to use typed interfaces to implement commands for kafka services * Ockam - Library - Validate CBOR structs according to the cddl schema for nodes/models/transport and nodes/models/workers * r3bl-open-core - [tuify] API change the return type of select_from_list() 3 * r3bl-open-core - Improve "Bug report" issue template

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

Updates from the Rust Project

405 pull requests were merged in the last week

stabilize dyn upcasting coercion (RFC #3324)

add an experimental feature gate for function delegation

enable Rust to use the EHCont security feature of Windows

enable profiler in dist-powerpc64-linux

enable the Arm Cortex-A53 errata mitigation on aarch64-unknown-none

remove now deprecated target x86_64-sun-solaris

EvalCtxt::commit_if_ok don't inherit nested goals

intercrate_ambiguity_causes: handle self ty infer + reservation impls

add Span to TraitBoundModifier

add debug_assert_nounwind and convert assert_unsafe_precondition

add allow-by-default lint for unit bindings

allow defining opaques in check_coroutine_obligations

call FileEncoder::finish in rmeta encoding

coverage: simplify building coverage expressions based on sums

do not erase late bound regions when selecting inherent associated types

don't ICE when ambiguity is found when selecting Index implementation in typeck

don't ICE when encountering placeholders in implied bounds computation

don't consider generic args of supertrait in deref_into_dyn_supertrait lint

don't require intercrate mode for negative coherence

eagerly compute output_filenames

fix early param lifetimes in generic_const_exprs

fixes error count display is different when there's only one error left

improve tool-only help for multiple #[default] variants

make PlaceholderReplacer shallow_resolver and recur when infer vars

note about object lifetime defaults in does not live long enough error

print query map for deadlock when using parallel front end

relate Inherent Associated Types using eq

remove --check-cfg checking of command line --cfg args

remove HirId from QPath::LangItem

separate NaN/Inf floats with _

suggest swapping the order of ref and box

the unadjusted ABI needs to pass aggregates by-value

tighten up link attributes for llvm-wrapper bindings

typeck break expr even if break is illegal

use an absolute path to the NUL device

when failing to import core, suggest std

add VarDebugInfo to Stable MIR

add support for global allocation in smir

fix smir's Ty::Ref pretty printing

expand Miri's BorTag GC to a Provenance GC

validate there are no critical call edges in optimized MIR

miri: GC the dead_alloc_map too

miri: check that target features required by LLVM intrinsics are enabled

miri: refactor float_to_int_checked to remove its generic parameter and reduce code duplication a bit

cache flags for ty::Const

indicate that multiplication in Layout::array cannot overflow

rewrite exhaustiveness in one pass

AmbiguityCause should not eagerly format strings

specialize SpecFromElem for ()

refactor binary_search_by to use conditional moves

stabilize ptr::addr_eq

add BufRead::skip_until

kmc-solid: I/O safety

add Duration::abs_diff

non null convenience ops

hashbrown: specialize fold implementation of iterators

cranelift: implement another batch of vendor intrinsics

cargo: refactor(toml): Better abstract inheritance details

cargo: exited with hard error when custom build file no existence or not in package

cargo: add CARGO_RUSTC_CURRENT_DIR (unstable)

cargo: use custom error instead of anyhow

cargo: review and remove ignored tests in rustfix

cargo: try running on windows

rustdoc-search: add support for traits and associated types

rustdoc-search: avoid infinite where clause unbox

rustdoc-search: simplify checkPath and sortResults

rustdoc: sort unstable items last instead of first

rustfix: add notice that rustfix has moved

clippy: TypeckResults::node_type() can be used inside of bodies

clippy: deprecated_semver: Allow #[deprecated(since = "TBD")]

clippy: manual_try_fold: check that fold is really Iterator::fold

clippy: missing_asserts_for_indexing: work with bodies instead of blocks separately

clippy: needless_return_with_question_mark: don't lint if never type is used for coercion

clippy: ptr_arg: recognize methods that also exist on slices

clippy: add new check_private_items config

clippy: create new lint option_map_or_err_ok

clippy: don't suggest a.mul_add(b, c) if parameters are not float

clippy: extend result_map_or_into_option lint to handle Result::map_or_else(|_| None, Some)

clippy: fix box_default behaviour with empty vec![] coming from macro arg

clippy: fix iter_kv_map false positive into_keys and into_values suggestion

clippy: improve error messages format

clippy: remove underscore check for manual_non_exhaustive lint

clippy: suggest alternatives to iterate an array of ranges

clippy: use absolute path for declare_tool_lint in declare_clippy_lint

rust-analyzer: cancelable initialization

rust-analyzer: editor/code: add option to suppress internal error notifications

rust-analyzer: ensure renames happen after edit

rust-analyzer: fix variant resolve for type alias

rust-analyzer: fix: add fallback for completion label details

rust-analyzer: fix: better resolve assoc item with type bound

rust-analyzer: fix: dedup duplicate crates with differing origins in CrateGraph construction

rust-analyzer: fix: remove parenthesis should ensure space

rust-analyzer: improve completion label details display

rust-analyzer: replace option.map(cond) == Some(true) with option.is_some_and(cond)

Rust Compiler Performance Triage

A good week, despite a few PRs that pnkfelix opted not to mark as triaged. In particular, a broad set of primary benchmarks improved, due to improvements to resolve (PR #118188) and a one-pass rewrite of exhaustiveness (PR #117611).

Triage done by @pnkfelix. Revision range: 4f3da903..df0295f0

1 Regressions, 5 Improvements, 5 Mixed; 2 of them in rollups 84 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] Macro fragment specifiers edition policy

Tracking Issues & PRs

[disposition: merge] [rustdoc] Add highlighting for comments in items declaration

[disposition: merge] generalize: handle occurs check failure in aliases

Language Reference

No Language Reference RFCs entered Final Comment Period this week.

Unsafe Code Guidelines

No Unsafe Code Guideline RFCs entered Final Comment Period this week.

New and Updated RFCs

RFC: constants in patterns

Add RFC combining Infra and Release teams

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.

Upcoming Events

Rusty Events between 2023-11-29 - 2023-12-27 🦀

Virtual

2023-11-29 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Atomics & Locks Book Club Final Chapter! (Chapter 10)

2023-11-30 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2023-11-30 | Virtual (Dublin, IE) | Rust Dublin

Automating expertise with cargo-semver-checks

2023-12-01 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Rust & C++ Christmas Game Jam Kick-Off!

2023-12-02 | Virtual (Kampala, UG) | Rust Circle Kampala

Rust Circle Meetup

2023-12-05 | Virtual (Berlin, DE) | OpenTechSchool Berlin

Rust Hack and Learn | Mirror

2023-12-05 | Virtual (Buffalo, NY, US) | Buffalo Rust Meetup

Buffalo Rust User Group, First Tuesdays

2023-12-06 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2023-12-10 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Rust & C++ Christmas Game Jam Finale

2023-12-12 | Virtual | Mainmatter

Workshop: Telemetry for Rust applications

2023-12-12 | Virtual (Dallas, TX, US) | Dallas Rust

Second Tuesday

2023-12-14| Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2023-12-14 | Virtual (Nuremberg, DE) | Rust Nuremberg

Rust Nürnberg online

2023-12-17 | Virtual (Tel Aviv, IL) | Code Mavens

Don't panic! - Our journey to error handling in Rust

2023-12-18 | Virtual (Munich, DE) | Rust Munich

Rust Munich 2023 / 5 - hybrid

2023-12-19 | Virtual (Berlin, DE) | OpenTechSchool Berlin

Rust Hack and Learn | Mirror

2023-12-20 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Adventures in egui app dev

Asia

2023-12-16 | Delhi, IN | Rust Delhi

Meetup #4

Europe

2023-11-30 | Brussels, BE | Lambda Brussels

Lambda Brussels

2023-11-30 | Copenhagen, DK | Copenhagen Rust Community

Rust metup #42 sponsored by Nine A/S

2023-11-30 | Vienna, AT | Rust Vienna

Rust Vienna Meetup - November

2023-11-30 | Zurich, CH | Rust Zurich

November Meetup

2023-12-06 | Cologne, DE | Rust Cologne

December Meetup

2023-12-07 | Aarhus, DK | Rust Aarhus

Rust and Talk at Danske Commodities

2023-12-07 | Lille, FR | Rust Lille

Rust Lille #5

2023-12-14 | Augsburg, DE | Rust - Modern Systems Programming in Leipzig

Augsburg Rust Meetup #4

2023-12-18 | Munich, DE + Virtual | Rust Munich

Rust Munich 2023 / 5 - hybrid

2023-12-19 | Heidelberg, DE | Nix Your Bugs & Rust Your Engines

Nix Your Bugs & Rust Your Engines #1

2023-12-19 | Leipzig, DE | Rust - Modern Systems Programming in Leipzig

Tauri, an Electron-alternative

North America

2023-11-29 | Chicago, IL, US | Deep Dish Rust

Rust Hack Night

2023-11-30 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2023-12-07 | Seattle, WA, US | Seattle Rust User Group

Seattle Rust User Group Meetup

2023-12-12 | Seattle, WA, US | Cap Hill Rust Coding/Hacking/Learning

Rusty Coding/Hacking/Learning Night

2023-12-12 | New York, NY, US | Rust NYC

Rust NYC Monthly Mixer: Share, Show, & Tell! 🦀

2023-12-19 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

Oceania

2023-11-28 | Canberra, ACT, AU | Rust Canberra

November Meetup

2023-12-05 | Aukland, NZ | Rust AKL

Rust AKL: Advanced Async Tricks + Interruptible Software

2023-12-11 | Perth, WA, AU | Rust Perth Meetup Group

Rust End of Year Event

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

I'd like to report that Rust's compile times were OK today and yesterday and the day before.

I'll keep you posted.

– ZiCog about slow Rust compile times on rust-users

Thanks to Michael Bryan 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

nehaprem · 2 years ago

Text

"From Oak to Java: Tracing the Evolution of a Revolutionary Programming Language"

Java's Origins:

Java, an Object-Oriented programming language, was conceived by James Gosling in the early 1990s, with the goal of creating a language for digital devices like set-top boxes and televisions. Initially considering C++ but facing memory constraints, Gosling shifted to creating a new platform, initially named "Greentalk," with the file extension .gt, which later transformed into "OAK."

Choosing "Oak":

The name "Oak" was inspired by an oak tree near Gosling's office, symbolizing strength and also being the national tree of several countries. However, due to trademark conflicts with Oak Technologies, the project was eventually renamed "JAVA" after an extensive brainstorming session, which included several other options like DNA, SILK, and RUBY. The unique and memorable nature of "Java," derived from a type of coffee bean, led to its selection, a name inspired by a coffee break near Gosling's office.

Java's Journey:

Built on principles of robustness, portability, platform independence, high performance, and multithreading, Java was recognized as one of the Ten Best Products of 1995 by TIME MAGAZINE. Presently, Java finds application in various domains such as internet programming, mobile devices, games, and e-business solutions.

Java's Evolution:

Over the years, Java has undergone significant transformations since JDK 1.0, with numerous additions and extensions to the standard library, expanding from a few hundred classes in JDK 1.0 to over three thousand in J2SE 5.

Highlighting Their Key Developments and Enhancements:

JDK Beta (1995): This was an early stage in Java's development, representing the initial testing and experimentation phase.

JDK 1.0 (January 1996): The Very first version was released on January 23, 1996. The principal stable variant, JDK 1.0.2, is called Java 1.

JDK 1.1 (February 1997):

It was released on February 19, 1997. There were many additions in JDK 1.1 as compared to version 1.0 such as

· A broad retooling of the AWT occasion show

· Inner classes added to the language

· JavaBeans

· JDBC

· RMI

J2SE 1.2 (December 1998):

“Play area” was the codename which was given to this form and was released on 8th December 1998. Its real expansion included: strictfp keyword

· the Swing graphical API was coordinated into the centre classes

· Sun’s JVM was outfitted with a JIT compiler out of the blue

· Java module

· Java IDL, an IDL usage for CORBA interoperability

· Collections system

J2SE 1.3 (May 2000):

Codename- “KESTREL” Release Date- 8th May 2000 Additions:

· HotSpot JVM included

· Java Naming and Directory Interface

· JPDA

· JavaSound

· Synthetic proxy classes

J2SE 1.4 (February 2002):

Codename- “Merlin” Release Date- 6th February 2002 Additions: Library improvements

· Regular expressions modelled after Perl regular expressions

· The image I/O API for reading and writing images in formats like JPEG and PNG

· Integrated XML parser and XSLT processor (JAXP) (specified in JSR 5 and JSR 63)

· Preferences API (java.util.prefs)

· Public Support and security updates for this version ended in October 2008.

J2SE 5.0 (September 2004):

Codename- “Tiger” Release Date- “30th September 2004”

Originally numbered as 1.5 which is still used as its internal version. Added several new language features such as

· for-each loop

· Generics

· Autoboxing

· Var-args

Java SE 6 (December 2006):

Codename- “Mustang” Released Date- 11th December 2006 Packaged with a database supervisor and encourages the utilization of scripting languages with the JVM. Replaced the name J2SE with java SE and dropped the .0 from the version number. Additions:

· Upgrade of JAXB to version 2.0: Including integration of a StAX parser.

· Support for pluggable annotations (JSR 269).

· JDBC 4.0 support (JSR 221)

Java SE 7 (July 2011):

Codename- “Dolphin” Release Date- 7th July 2011 Added small language changes including strings in the switch. The JVM was extended with support for dynamic languages. Additions:

· Compressed 64-bit pointers.

· Binary Integer Literals.

· Upstream updates to XML and Unicode.

Java SE 8 (March 2014): Released with the codename "Spider," this version introduced language level support for lambda expressions and default methods. It also included a new date and time API inspired by Joda Time.

Java SE 9 (September 2017): This version introduced Project Jigsaw, which aimed to modularize the Java SE platform. It implemented a standard module system for the Java SE platform and the JDK.

Java SE 10 (March 2018):

Released Date- 20th March Addition:

· Additional Unicode language-tag extensions

· Root certificates

· Thread-local handshakes

· Heap allocation on alternative memory devices

· Remove the native-header generation tool – javah.

· Consolidate the JDK forest into a single repository.

Java SE 11 (September 2018):

Released Date- 25th September, 2018 Additions-

· Dynamic class-file constants

· Epsilon: a no-op garbage collector

· The local-variable syntax for lambda parameters

· Low-overhead heap profiling

· HTTP client (standard)

· Transport Layer Security (TLS) 1.3

· Flight recorder

Java SE 12 (March 2019):

Released Date- 19th March 2019 Additions-

· Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)

· Microbenchmark Suite

· Switch Expressions (Preview)

· JVM Constants API

· One AArch64 Port, Not Two

· Default CDS Archives

In conclusion, Java's journey from its early inception as "Oak" to its eventual renaming as "Java" represents a fascinating tale of innovation and adaptability. Java's evolution, marked by its recognition as one of the Ten Best Products of 1995 by TIME MAGAZINE and its widespread adoption across diverse industries, is a testament to its enduring significance and impact on the modern technological landscape. As Java continues to evolve with each version, it remains a cornerstone of the programming world, embodying the principles of robustness, flexibility, and adaptability that have propelled it to its current prominence.

For individuals aiming to enhance their Java expertise, exploring the offerings of ACTE Technologies is highly recommended. With proficient instructors well-versed in Java instruction, ACTE Technologies provides a range of flexible learning options, accommodating both online and in-person preferences. Java program at ACTE Technologies includes certification options and support in finding job placements.

1 note · View note

dirtcube · 2 years ago

Text

Minecraft Server Hosts (Java)

So, you want to run a minecraft server for you and your pals, but you don't know where to go to get a good host worth your price that won't suck ass.

How do you know what server hosts are good? What do all the specs mean? Are they lying to you?

Now, I'm not the single voice on this stuff by any means, and I'm sure there's much more info better than what I've got... But I have been running private minecraft servers since 2012 and I feel like I have at least a little bit of knowledge and experience to share.

More below.

I am going to discuss all possible server hosting methods through the following categories: Pricing, Performance, Trustworthiness, Accessibility

I will also emphasise something important: It does not matter how many cores the CPU of your host has, minecraft runs only on a single thread even for servers. Anything of minecraft that runs on multiple threads is very much just light stuff, but the main game runs on a single thread. There ARE mods that attempt to multithread minecraft, but they are all experimental and buggy as fuck. Worth trying, but not worth depending on.

You need to figure out what CPU they use and if it works for single threads. Multi-threaded server hosts are just bragging about the hardware. You can find a list of CPU's good at single-thread processing HERE

In addition, more RAM =/= Better Performance. In fact, too much RAM can be detrimental because your CPU can't keep up with collecting the garbage data and disposing of it. In an ideal setting of your-average-friend-group you will need maybe 8-10gb of RAM dedicated. Never dedicate the full possible amount of RAM you can have for your server, always do 1GB less so the server has breathing room if necessary. So i.e if you have 12GB available, you put the max to 11GB.

Now that that's out of the way, we can begin with the review.

Let's first start with the most obvious one that I 100% suggest if you have some semblance of tech saviness or a tech savvy relative you can ask the assistance of.

SELF HOSTED SERVER

Your BEST option is always to self-host. But NOT on your own device. If you choose to run a dedicated server on the same device you intend to play on, you will have a bad time unless your PC is a beast. On top of that, your server will not be able to run 24/7. I do not recommend doing this unless you have a dedicated serverroom or a robust PC dedicated to only doing these things.

But, with self-hosted I mean specifically: Purchasing a cloud server from a decent host and installing everything yourself.

Price: The prices tend to come quite cheap for what you get. My private server is ~2TB of storage, Pretty good hardware, and 16gb of RAM available. You can get something small and cheap for only 12$ but if you want to use it for more than just minecraft you can get more.

Performance: Performance is tricky. You have to do your research on what you'll need for your server to run well. In my case, we're asking a contract change soon to upgrade the hardware of our server to an i7 because our current hardware does not handle single-thread servers very well.

However, once you've gone past the trickiness, the performance of a self-hosted server can be great and will outmatch most dedicated minecraft server providers.

Self hosting is great for Vanilla or Modded.

Trustworthiness: Its as trustworthy as you can make it. PLEASE look properly into server security so your entire service doesn't get hacked- not just your minecraft server. I can't say much on this topic as my father handles this side of things more than me.

For your minecraft server specifically, the best way to keep it safe is always keep on a whitelist, even if you wont be sharing the IP publically. Ensure you run your server not on the default 25565 port. Server scrapers will try to break in- we've had it happen with mine literal MINUTES after launching it! Server scrapers are bot accounts that will try to identify any open, unwhitelisted servers on the 25565 port. These scrapers can have the possibility of identifying multiple things about any server such as: Server version, if it's modded, its MOTD, playercount, and if the whitelist is off. (Do note that that whole rumor of Jeb_'s server being found and griefed that FITmc spread is likely entirely false, video explanation here, but this does not negate the fact that people can scrape this info rather easily.)

Accessibility: It's not accessible to people who know fuckall about tech. A decent amount of tech literacy is required to understand how to run a server like this. It is, however, incredibly worthwhile to learn. It's not convenient to self-host unless you already happen to be running your own private cloud or whatever.

MINECRAFT REALMS

Pricing: 8$/month, 30-day Realm for 10$, 90-day Realm for 27$ If you don't want to be stuck in a subscription, you pay more! How scummy. Good job microsoft.

Performance: 4GB world size max, No Modding, Render & Simulation distance is locked to a max of 8 and can not be altered in any way. This means regardless of how big YOUR personal render distance is, it won't go beyond 8 because the server locks it. One realm can have up to 3 world "slots", but only one can be active at a time. There is no static info about how much GB RAM they have dedicated, based on what I found their RAM is dynamic? It's unclear as they probably don't want to 100% disclose their specs.

Trustworthiness: It's microsoft. If you trust em, good for you.

Accessibility: Incredibly accessible as there is basically zero setup on the user's end.

Verdict: Not worth it unless you really dont want to deal with alternate hosts.

BISECT HOSTING

To be up front, I have not USED this one, so i'm speaking from what I'm seeing. and able to research

Pricing: Has Premium & Budget. a 6GB server (recommended modpack minimum) is 30$ for Premium, and 18$ for budget. The difference between Premium and budget is automatic modpack installation, Adjustable player slots, dedicated IP, automated backups, and a few others that dont matter to the average player. It is not really worth the markup.

Performance: They use Intel Xeon processors, SSD's, in general their specs are *really* good and I would not be surprised if their servers run entirely smoothly. However, the claim that a server can have up to 12 players online with only 1GB of ram (their cheapest option at 3$) is giving people false hope. Even the original minecraft realms offers gave a minimum of 2GB and did not expect more than two players to be able to play at a time.

Trustworthiness: I can't speak for this, but based on their support offers and their money-back guarantee, on top of general reviews stating they're very reliable, I would say they're trustworthy.

Accessibility: All server hosting comes with what is basically a multicraft control panel, which is very accessible. Automatic server installation is also very accessible and friendly. In general, I would say it seems to be good for anyone looking for a good server that's easy to set up and has everything you need.

Verdict: Ridiculously pricy, but if you have the money and don't want to deal with hassle its worthwhile. On top of that, a lot of modders are sponsored by them, so you can often use a promo code to get 25% off of your server and support a modder that way. (Though frankly if you want to support a modder I'd just throw a few bucks to their dono page or smth)

MC PRO HOSTING

Pricing: 6GB ram (minimum for modpacks) is 34$/month, Their customisable package looks convenient and cheap, but honestly would likely result in "set up your server with worse features for more money". It's very tricksy.

Performance: They claim you can have 100 possible players on only 6GB of ram. Even the best servers struggle with 100 players and I can tell you they certainly have more than 6GB dedicated- it's boasting numbers to sound good and it is absolutely not accurate. They also boast Intel Xeon processors which are at least good for minecraft, and they seem to have stopped boasting that they got multiple cores which was misleading.

Trustworthiness: They have a history of actively lying about their service and how well it can do things, on top of boasting in the past that having multi-threaded CPU's was good for the server. They changed this, which is good, but I personally don't like it. They provide DDoS protection and last I used them their support team was active and quick, which is good. Daily backups with no extra costs is also very kind of them.

Accessibility: Quick to set up and access, back in the day their control panel was a mess, they probably fixed it now.

Verdict: Overpriced and lying about the capabilities of their service, but if you know the limits yourself and can manage the server with those limits in mind you would have a decent server host.

SPARKEDHOST

Pricing: Offers Budget, Enterprise, and Extreme options. Assuming the 6GB modpack minimum... Budget: 6$, Enterprise 13$, Extreme 24$. Pricing is very reasonable, especially for what it offers in performance.

Performance: Offers Intel Xeon Processors *or* the equivalent. Take note of that. What is fascinating to me, is that their Extreme offers do boast MUCH better single-thread performance. Meaning they are aware how important the single-thread performance is for minecraft servers.

Trustworthiness: They don't boast how many players a server can host, which is great. However, it does boast that it has multiple cores (aka threads) available in its services. which, as you know, is basically useless for minecraft. On the other hand, as mentioned above the service does boast that single thread performance is increased for its extreme packages, meaning that they are open about the importance of that for a minecraft server. Having used this service before, I also must say that they are reliable and quite responsive on the support team.

Accessibility: Their control panel is pleasant to use and easy to understand. It's a pretty good server host and the fact they do explain the importance of single thread makes it more accessible to people trying to figure out how to find a good server. Other than that, it is basically like any other server host. It does not boast automatic modpack setup, though.

Verdict: Frankly one of my favourite server hosts and the one I would utilise if I didn't have a self-hosted one. Cheap, reliable, and doesn't lie about the capabilities of the server to you.

NITRADO

This is the server host i'm using right now while my self-hosted server is down for maintenance for a while.

Pricing: It's default preset packages all boast 2GB of ram for at the lowest like 2$. Otherwise, it offers a customisable package. The service i'm using is a customised package, where I selected 4 slots, a 30 day runtime, and its maximum 7GB of ram for modpacks. It costed me 13$ or so.

Performance: I can not find any information on either their website or online about exactly what their specs are which... Isn't great. Supposedly its Intel Xeon too? But the performance is weak to say the least. In addition, the website control panel is slow as all hell and the server frequently has strange issues that at this rate I have attributed to the server launching incorrectly when doing its restarts. Because I have only a 30-day package I'm not bothering to contact support over this but... Keep it in mind.

Trustworthiness: Since they're not up front about their specs I can't say they're very trustworthy. They also separate their preset packages based on player slots and not server performance.

Accessibility: They have automatic modpack setup for a large amount of mods but are not up to date with the most recent curseforge available modpacks. Other than that their control panel is confusing and awkward to use and its more convenient to utilise their FTP file access rather than just the ease of uploading things to their website THROUGH their website.

Verdict: Not worth the money. I was trying it out to familiarise myself with their services for a potential ARK server but if a minecraft server is like this Im not gonna trust it for an ARK server.

NITROUS NETWORKS

Pricing: 6GB it asks 24$/month. It boasts its pricing based on amount of players it can handle and you all know the drill on that. Boasts support for all mods and has automatic mod setup included in the pricing which is nice.

Performance: It's information about the specs is a little wonky to find with how they just prattle on a line of info about specs instead of a nice list, but they provide Xeon processors too that are not on the single thread CPU benchmark list. make of that what you will. They also claim to offer 9900k servers which are at the very bottom of single thread performance. I frankly would not use this for modded, but I know it performed decently on vanilla. It did begin chugging once more than 4 players were online at a time, unfortunately, and we did have one of the higher packages too.

Trustworthiness: Their tech support is quick and you can request them to put you on their 9900k servers manually without extra cost afaik. However, they recommend the modpack minimum being the 3GB RAM package which is frankly just lying to your customers about the capability of your services.

Accessibility: Probably one of the most pleasant control panels i've had the joy of using. The website is sleek, responsive, and uploading files is easy.

Verdict: It's a good service, but gets outshined by cheaper, better, and more robust alternatives.

There is a slew of other server hosts out there too that I may not be aware of, but I hope that this review of some of the known ones can aid in helping you find your most preferred server host- or at least be educational to you in some form.

#minecraft #mineblr #mc tag #dirtcube chat #this is super long but also i hope my experience and information can aid y'all in not getting scammed #if there's one awful thing its being a server manager and having to deal with a shitty server host #this is specifically aimed towards private friend groups btw not like #huge money-making-scheme mc servers or public servers #but it could be of assistance if u intend to have a public server of some sorts

1 note · View note

drawpile-dev-diary · 4 years ago

Text

Drawpile 2.1 architecture overview

Recently, I dusted off the old "Rustpile" branch (my attempt to integrate my experimental Rust based reimplementation of the paint engine to Drawpile itself) and, to my pleasant surprise, discovered it was in a much better shape than I remembered. So, I've been reading through Drawpile's code and drawing a diagram of its overall architecture to get a better idea what it would take to complete the integration.

Here are my notes on the current state of Drawpile's architecture. If it seems unnecessarily complex, that's because it is. There are vestigial structures that no longer make sense and are streamlined away in the Rustpile version. But more on that in the future, here is the present:

The CanvasModel class that contains the state of the canvas, including the layer stack itself, as well as associated models needed by the GUI.

The StateTracker handles drawing commands and applies them to the layer stack. A big change in version 2.1 was that brush state is now entirely local, what is sent over the wire is a list of precomputed dabs. This made the protocol much less stateful, meaning the only thing the state tracker needs to keep track of anymore is the undo history. The Rustpile equivalent is called "CanvasState".

LayerList is a Qt list model. It is used by the layer list GUI widget. Its content is kept in sync with the actual layers in the layerstack.

LayerStack contains the actual layers, as well as other things related to the actual canvas content: the background tile and the annotations.

Layer contains tiles which contain the actual pixel data. Layers are sparse: fully transparent tiles can be presented by null pointers. This is an important optimization, as when multiple layers are used, most layers tend to be mostly transparent. Layers and tiles utilize copy-on-write, which makes copying layers very efficient. This is essential for the undo functionality, that relies on snapshots of the canvas state.

AnnotationModel is a Qt model that contains all the annotations. Annotations work much like text layers, but are not true layers: their stacking order is undefined, there are no guarantees that they render the same on all clients and they are always drawn on top of the canvas. This is a Qt model so that it can be easily accessed via QML (which is not yet implemented, so there is presently no need for this to be a Qt model.)

LayerStack Savepoint is a snapshot of the LayerStack's content. A savepoint can be created from a LayerStack and can then be used to revert the LayerStack to that point. This is unnecessarily complex. In the Rustpile implementation, whole LayerStack instances can be copied cheaply and lack interior mutability thus have no need for savepoints.

A LayerStackObserver is registered with a LayerStack to be notified of changes. An EditableLayer is created to wrap a Layer and add editing functions to it. It notifies the observers of the owning LayerStack when changes are made. In the Rustpile implementation, there is no EditableLayer wrapper, as layers cannot be mutated in place. Instead, all editing operations return an area of effect object that describes the affected area. These can be merged together and dispatched to observers when the LayerStack is updated.

A layerstack can have multiple observers, but in practice just one is enough. A specialized observer class instance that caches the flattened canvas as a QPixmap is shared by all GUI widgets (the canvas view and the navigator.)

The AclFilter stores the state of the access control list used to filter incoming messages. When a message is received, it's first passed to the AclFilter, which either accepts or rejects it. Certain messages affect the ACL itself (e.g. those setting layer lock bits.)

When a Recorder instance exists, it writes a copy of each received message into a recording file that can be later played back. When playing back a recording, ACL filtering is not necessary, since rejected messages were not saved. (For debugging purposes, rejected messages can be stored but marked as such, so they are ignored during playback.)

The Lasers, UserCursors and UserList models store the state of laser pointer lines, the positions of each users cursors and the list of logged in users, respectively. They are Qt models used by the GUI widgets. (Lasers and UserCursors are Qt models only for use in QML, which isn't presently done.)

Additionally, not visible in the diagram, is that the state tracker and the layer stack are referenced in various places:

In the layer list dock, the layerstack's censored bit is checked

The layer stack's view mode is set by an action in the main window

The layerstack is used by the flipbook window

The built-in thick server uses the layer stack, state tracker and ACL filter

The reset dialog needs access to the state trackers savepoints

The canvas view item and navigator reference the cached pixmap layer stack observer

The canvas scene references the annotation, laser and user cursor models

The canvas view widget needs to know the size of the canvas

The annotation editor references the annotation model

The canvas saver runnable needs a copy of the layer stack

The document class references the state tracker and the layerstack

The playback controller uses the state tracker

The annotation tool uses the annotation model

The bezier tool creates preview sublayers

The floodfill tool needs read-only access to the layer stack

Freehand tool needs read-only access to sample colors

The selection tool copies pixel data and creates temporary eraser sublayers

One big problem with the present architecture is that when the paint engine is heavily loaded (for example, when logging into a session and downloading the session history,) it blocks the main thread which leads to the GUI locking up and even disconnects as network traffic isn't being processed.

The solution to this would be to run the paint engine in a separate thread. However, this has proven challenge. From the list above, one can see that the layer stack is referenced in many places. The current workaround is to periodically relinquish control back to the eventloop when paint command execution is taking too long. However, the Rustpile work is an opportunity to fix the architecture to be more multithread compatible. Since in Rustpile, LayerStacks are easily copied, one can be kept around in the main thread for read-only access while a new version is being processed in the paint engine thread. More on this later...

5 notes · View notes

timetocode · 5 years ago

Text

Plans for nengi.js 2.0

Hi, this is Alex, the people’s network programmer and developer of nengi.js. Let’s talk about the future.

I consider nengi 1.x to be complete. Of course there are always unfinished items of work -- I wish I had a comprehensive tutorial series on prediction for example -- but really things have been stable and good for a long time.

So as I look towards 2.0, there are no fundamental changes to the library in mind. Instead the future is about improvement, making things easier, and staying open to deeper integrations with other libraries and possibly even with other languages.

One area of intended improvement is the whole process around forming connections both on the client and the server.

On the clientside, client.readNetwork() or equivalent is invoked every frame as the mechanism that pumps the network data into the application. However, this pump also controls the network data related to the connection -- meaning that without spinning the game loop one cannot finish trading the data back and forth that completes the handshake. I’d like to redo this such that we end up with a more normal api, e.g. client.connect(address, successCb, failCb) or equivalent. This presents a clean flow with no ambiguity as to when a connection is open. It’ll also let the clientside of games be a bit tidier as they don’t need to spin the network in anticipation of a connection opening.

On the serverside the whole .on(‘connect’, () =>{}) warrants a redo. I have in mind a simpler api where a ‘connectionAttempt’ occurs, and then the user code gets to invoke instance.acceptConnection(client, greeting) or instance.denyConnection(client, reason) thus again providing a nice and clean exact line after which we know what state the connection is in (attempted => connected, or attempted => denied).

Another area is Typescript support and some positive side-effects thereof. Nengi has minimal typescript definitions, but I think the actual surface of each api class/function should be rewritten in actual typescript. This will be limited, as the actual inner workings of nengi are truly untyped -- it has its own crazy typesystem and fancy optimization of high speed iteration based on object shapes that I should stop talking about now before I accidentally write a dissertation.

Per adding Typescript support there will be a major benefit to Typescript and JavaScript developers alike which is the opportunity for some top tier intellisense. The nengi api is small and having some modest documentation pop up right as you type things like .addEntity would be awesome.

The other benefit (ish..) of formally supporting Typescript is that a few of the processes around how to integrate game logic and nengi could finally be strictly addressed. I used to favor a very laissez-faire approach to integration as I didn’t want to stifle anyone’s style… but as time has gone by it seems that the level at which nengi can be decoupled is not seen as powerful, and instead it just confuses people. I want a better newbie experience, and presenting things like “well you can kinda do anything” isn’t helpful. I wouldn’t necessarily limit nengi itself, and instead may supply this functionality as a layer, but I would like to suggest a much stricter boilerplate for topics such as associating game data with a connected client and any other spot where game and network get glued together.

On that note of making things less open ended, I am *considering* whether nengi should offer an Entity and Message etc as part of the api. Currently entity is a concept or an implied interface -- really it is any object. Too decoupled? Maybe something more explicit would be nice. We’ll see.

More advanced protocols/schemas are also needed in the future. There are a bunch of features that can easily come from having more options on the protocols, but initially I plan to skip over all of these features and just change the api in a hopefully future-proof manner. The plan here is to change things from protocol = { x: Int, y: Int, name: String } to something more like context.defineSchema({ x: Int, y: Int, name: String }). Initially these will do the same thing, but in the future more arguments will be added to defineSchema.

The eventual removal of types from nengiConfig is another dream feature that may or may not make 2.0 but is worth a bit of discussion. NengiConfig.js is that file where every entity, message, command etc is listed out. Removing this would require nengi to be able to explain *in binary* how to *read future binary* and is non-trivial. The benefit however is that the parallel building of client and server code would no longer be a strict requirement. In the end of course a client and server need to be built for one another, but if the relationship were less strict than it is now it may pave the way for eventual nengi clients that aren’t even JavaScript. To me this has always been a bad joke -- who would want such a thing??? But as the years have passed it has become clear that nengi is not just special for being JavaScript, but that it is actually competitive in performance and functionality with the type of technology coming out of AAA multiplayer gaming companies (send money!!). So this may not be a bad direction (though it is worth noting there are at least two other major changes needed on this path).

There would also need to be changes to the current ‘semver’-ish release cycle. As it stands currently nengi version numbers follow the rules of breaking changes on major release (1.0.0) non-breaking changes on minor release(0.1.0) and small patches on patch release (0.0.1). As the current version of nengi is 1.18.0 that means that I’ve managed to add all functionality since release without a single breaking change (send money?!). This is not easy. These new changes described above are deliberately breaking api changes. Given the work cycle that I’m on and the lack of funding, the most efficient way for me to work would be with breaking changes allowed and perhaps a changelog to help the users out. So 2.0.0+ may shift to this type of development, where the ‘2’ is just my arbitrary name for the functionality, and 2.1.0 is a potentially breaking change. Obviously no one has to join me over in the land of nengi 2 until it becomes more stable, but letting me do *whatever* will get everything done faster, which is more important than ever given my limited time.

In the category of “maybe 2.0 things” here are a bunch of other things I’d like to talk about too, but they’re too involved (and experimental) of topics to go into detail. Here’s a vague summary of things I’ve put R&D time into:

Experimentally rewrites of sections of nengi in Rust, C, C++ with integrations via n-API, wasm transpilation, and some in-memory efforts. Crossing the boundary between JavaScript and anything else has been problematic as a means of solving most obvious problems, but some less-than-obvious problems may yet warrant this approach. I would say that n-API is a dead end for most nengi functionality but has some merit for spreading sockets across threads. WASM, or specifically working on a continuous block of memory may have some promise but requires further R&D.

An advanced rewrite of the nengi culler based on spatial chunking (promising!).

A middle api between serving up interpolated snapshots and the nengi client hooks api. This would become a generic replacement for the entire nengi clientside api. Until further typescript support I’m going to leave this one alone as it is very likely that a naturally elegant solution will show itself in the near future.

Multithreaded nengi, specifically the spreading of open connections across threads and the computation of snapshots. True optimal CPU use is opening multiple instances, not giving more threads to an instance, but there are some uses nonetheless.

Multi-area servers that use spatial queries instead of instances or channels (for example creating multiple zones, but not making an instance or channel per zone, instead the client.view just goes to a different space with some spatial math).

So yeah, that’s the plan! Thanks for your support (send money)

https://github.com/sponsors/timetocode

https://www.patreon.com/timetocode

#nengi.js #javascript #multiplayer #game development #programming

2 notes · View notes

datascience-from-the-trenches · 5 years ago

Text

Experimentation with resource constraints: the virtual warehouse

https://multithreaded.stitchfix.com/blog/2020/11/18/virtual-warehouse/

#ab testing #experimentation #data analytics #data science

1 note · View note

scribe-awoken · 2 years ago

Text

what's even more wild is that there was another file format, JPEG XL, which could've actually become the one-image-format-to-rule-them-all. Some of the improvements over the existing JPEG format include lossless compression mode with smaller filesizes than normal lossy JPEGs, animation, transparency, HDR and multithreaded decoding, while also being fully backwards-compatible (i.e. they'd be rendered as normal JPEG files in software that didn't have compatibility with the new features).

So many big players in the tech industry were on board. Facebook, Intel, Adobe, Nvidia and Shopify were all working on implementing support for it into their products and services. KDE, the open source community behind Krita, Kdenlive, and the plasma desktop environment for Linux (the same one SteamOS uses in desktop mode) already had their implementation ready to go and integrated into their software. Media companies like The Guardian were also pushing for its inclusion in Chromium. There was pretty much universal support for the format across the board...

Except Google, who dropped what little experimental support for the format was in Chromium, and straight-up ignored all feedback from those other organizations asking them to make it a permanent feature rather than dropping support entirely. And it's pretty much entirely because it was in competition with webp (the manager at Google behind the decision was one of the co-authors of the webp format) and AVIF (which Google is pushing as their preferred successor to webp).

The wildest part is that even other engineers at Google were like "this is a bad idea. why are you doing this?" in the bug report discussion regarding this!

me when i meet the person who created webp files

98K notes · View notes

enki2 · 7 years ago

Text

For a couple years i the early naughts, I mostly ran DOS with various experimental / unusual (non-windows) GUIs on top. The most interesting one was a family of projects called XGUI that someone who I met in a chatroom about QBASIC gave me. He had been the hanger-on of a small group of weird but skilled programmers who had developed a whole bunch of projects, including TACKLE (a low-level language for 16-bit os dev modeled on a combination of NASM-style assembly and QBASIC) and the XGUI series of graphical environments. As far as I know, nobody but me & these guys ever used it: I was told not to distribute it further because the guy wasn’t sure if they still planned to release it (even though he hadn’t been in touch with them for years). I’ve since lost the files & lost touch with the guy who gave me them (since I only spoke to him through AIM, which is now defunct).

The XGUI projects were weird but also kind of brilliant.

I used two different generations of XGUI with no shared code. I forget the exact version names, so I will call them XGUI 2 and XGUI 3. XGUI 3 was sensible and conventional for what it was trying to do: it had its own special bytecode that all applications were in, which it interpreted, and a language for application development.

XGUI 2 was very different. It ran regular DOS applications, kind of, and made them multithread, kind of. Specifically: it provided a library of drawing routines and routines for loading current state from disk. A third-party application would, upon running, perform a single draw cycle and then exit. The XGUI 2 controller program would run whatever running application repeatedly, putting events & mouse position in the on-disk state.

It had some unusual features as a side effect of this structure. For instance, it had alpha, implemented by drawing every other pixel beneath the open window's position (expecting mode 13/xmode, and expecting the switch to xmode to restore the framebuffer). But, also, the screen would constantly flash while you were using it.

XGUI 2 had 'multi-threading' because it could run two different programs in a row with different non-overlapping screen positions, and the flashing would get worse but it was basically non-preemptive multitasking. XGUI 3, despite literally being a VM, only ever ran the currently focused app.

#mine

6 notes · View notes

themeparkitect · 7 years ago

Text

Devlog Update 194

One of my favorite things in simulation games is seeing your creation come alive and just sitting back, watching all the bustling activity. In Parkitect it’s mostly all the guests running around who are responsible for creating this effect, and it’s not quite yet where we want it to be. “The more the better” has been a sort of unofficial motto throughout development for us, whether it be object counts, park sizes or the amount of rides - the more we can add the better it’ll be for this game.

Guest counts are still lower than we’d like though and right now is the last good time to properly solve this, since increasing the amount of guests also affects the money balance and the entire campaign. Improving guest performance has been a constant task nearly every month throughout development and it’s at a point now where the only significant further improvements can be gained from multithreading. The main hurdle there is that Unity, the game engine we’re using, is making multithreading really difficult. They are currently making very impressive progress to improve that for the future, but it’s too late for Parkitect to use the solutions they are working on. So I have finally started with finding my own solutions for these difficulties. It’s a very annoying task that requires going through the entire guest AI code and making it compatible, but so far it looks like it’ll be worth it!

As a first smaller improvement, overall performance in Beta 7 will be up to 15% better in busy parks.

The really big improvement will not be in Beta 7 just yet, but I hope I can release an experimental version for anyone interested in testing sometime during June. In the first tests it looks like we should be able to have quite a few more guests while at the same time having better performance overall. Here’s a small teaser:

That’s 8000 guests in a pretty detailed and big park (Northern Highlands), with roughly 1500 guests on screen, running at 65 FPS!

This is just a stress test of course and we won’t increase the guest count anywhere near this dramatically, because 1) it turns out “the more the better” has a limit where it stops being fun and 2) the game needs to run on weaker systems as well. Comforting to know though that guest performance should never be an issue again after all of this! You should also actually start seeing guests complain about long queue lines...

#weekly

37 notes · View notes

knight-otu · 2 years ago

Text

Toady's Devlog for 06/08/2023

Toady One, from the Dwarf Fortress Development Log:

Here's the June report and the Future of the Fortress reply. This month we have several goals. We're going to start by getting the experimental branch moved over to the main line. The update of the engine from SDL to SDL2 is stable, and there will also be a multithreading option. It's off by default until we get some more testing done on the experimental branch, but the speed gains are significant, so it will be available in the settings as well. The update to SDL2 was the most important change for ports, so Linux and Mac versions are much closer now. Adventure mode work is underway! I have an adventurer running around in the graphical play area. As with fortress mode, the game already exists, but now we need to work through the interface for every possible action and event, as well as creating the sound landscape with our new audio engineers. This will be a long process, but it'll be fun to watch it come together, and we'll be able to update regularly on our progress there now that adventure work has finally begun. Over in fortress mode, Putnam's almost ready with a menu to review old reports and announcements and is working on making filterable-sortable lists more consistent. Between the adventure work I should have a chance to look at ammunition issues this month as well. And we've got additional tree and plant graphics coming down the line, as well as graphical improvements to engravings, bookshelves, and more.

#Dwarf Fortress #Development log

9 notes · View notes

victoriasmith572 · 4 years ago

Text

The inability of Node.js to process CPU bound tasks is another huge drawback of the platform. When Node.js receives a CPU bound task and a heavy request comes to the event loop, it sets all the CPU available to process it first, before it answers other queued requests. This leads to an overall delay in the event loop, and therefore to an inefficient computation process.

Overcoming the challenge: Leveraging the experimental feature of Multithreading Ever since multithreading got introduced in Node.js framework in 2018 as an experimental feature, it allowed to process heavy CPU-bound tasks by leveraging the new feature called “worker threads module”, although there were limitations on the kind of machines it allowed you to use the feature on. Machines with multiple cores can use the feature to leverage additional threads from a thread pool.

Since the issue occurs due to poor coding standards and lack of experience with JavaScript and Node.js frameworks in particular, good news is that it’s not difficult to fix. Ensure to keep your code shallow and modularized to keep it readable. Handle every single error (always reserve the first argument for the error) to make the code stable. Using typescript-based frameworks such as SugoiJS which you can use on top of Node JS is a good way to eliminate this drawback and make the codes simpler and more effective.

Jellyfish Technologies is a reputed global software development company that specializes in Node.js development services and can, in fact, accelerate your NodeJS development efficiently.

Visit Us:-https://www.jellyfishtechnologies.com/overcoming-node.js-development-challenges.html

#nodejs #nodejssoftware #nodejsdevelopmentcompany #hirenodejsdeveloper #nodejsdevelopmentcompanyinUSA

0 notes

akirameta84 · 2 years ago

Text

by a shit ton. ive seen people on the subreddit say their saves that had suffered fps death were more than playable again. and it has multithreading

its very stable, and the devs are hoping to get the sdl2 update (experimental) onto the main branch soon

love games with heavy mod support

im now playing kobold fortress instead of dwarf fortress after barely being able to survive under normal circumstances (but i picked a mod that explicitly doesnt make the kobolds that different- except that theyre gayer and more gender neutral than dwarves are on average which i love). you can edit the orientation odds for dwarves with the files too which is great lmfao

my little dragon dudes

95 notes · View notes

scrummethodologiestrainingw-blog · 5 years ago

Text

What Is Agile Methodology In Project Management?

Just about every engineering Corporation now appears to practice the agile methodology for software improvement, or a Model of it. Or a minimum of they feel they do. Whether you are new to agile software advancement otherwise you uncovered software package progress many years back utilizing the waterfall program improvement methodology, currently your function is no less than affected from the agile methodology.

But what's agile methodology, And just how should really or not it's practiced in software improvement? So how exactly does agile advancement differ from waterfall in apply? What's the agile software improvement lifecycle, or agile SDLC? And what's scrum agile compared to Kanban along with other agile types?

Agile was formally introduced in 2001 when seventeen technologists drafted the Agile Manifesto. They wrote 4 key concepts for agile job administration, With all the intention of building improved application.

Prior to Agile: The period of waterfall methodology. Previous fingers like me try to remember the days if the waterfall methodology was the gold normal for software package enhancement. The application progress system necessary a lot of documentation up front in advance of any coding started off. A person, normally the small business analyst, first wrote a company specifications doc that captured almost everything the enterprise desired in the appliance. These business necessity files ended up very long, detailing all the things: Total strategy, in depth practical specifications, and Visible user interface layouts. [Source]

Technologists took the enterprise need document and designed their particular complex specifications doc. This document defined the appliance’s architecture, facts structures, object-oriented functional styles, user interfaces, and other nonfunctional demands.

This waterfall program growth course of action would eventually kick off coding, then integration, and finally testing just before an software was deemed output Prepared. The entire course of action could quickly take a few many years.

We builders were envisioned to learn “the spec,” as the complete documentation was known as, just along with the files’ authors did, and we had been normally chastised if we forgot to thoroughly put into action a critical depth outlined on page 77 of a 200-web page doc.

Back then, software growth alone also wasn’t uncomplicated. Lots of progress instruments expected specialised training, and there wasn’t any where close to the open up supply or commercial software components, APIs, and World-wide-web providers that exist nowadays. We needed to acquire the low-stage stuff for example opening database connections and multithreading our information processing.

For even fundamental programs, groups were being massive and interaction instruments have been limited. Our complex specifications have been what aligned us, and we leveraged them much like the Bible. If a requirement transformed, we’d set the business enterprise leaders by way of a very long process of evaluate and log off because communicating variations across the group and repairing code was pricey.

Since the computer software was produced depending on the specialized architecture, decrease-degree artifacts have been developed initial and dependent artifacts afterward. Tasks ended up assigned by ability, and it was widespread for database engineers to assemble the tables and other databases artifacts first, followed by the appliance builders coding the features and company logic, and after that lastly the consumer interface was overlaid. It took months prior to any one noticed the appliance Operating and by then, the stakeholders were finding antsy and often smarter about whatever they really needed. No wonder employing adjustments was so highly-priced!

Not every thing you place in front of buyers worked as envisioned. Sometimes, customers wouldn’t make use of a function at all. Other periods, a ability was commonly successful but required reengineering to assistance the mandatory scalability and efficiency. Within the waterfall environment, You simply realized these items after the computer software was deployed, following a very long enhancement cycle.

Invented in 1970, the waterfall methodology was groundbreaking mainly because it introduced willpower to computer software enhancement in order that there was a transparent spec to adhere to. It absolutely was according to the waterfall producing method derived from Henry Ford’s 1913 assembly line innovations, which provided certainty as to every step inside the production system to guarantee that the final solution matched what was spec’d in the first place.

If the waterfall methodology came for the program environment, computing programs and their applications have been normally complex and monolithic, necessitating a self-discipline and apparent outcome to provide. Specifications also changed slowly as compared to today, so huge-scale endeavours had been significantly less problematic. The truth is, methods were being created underneath the belief they'd not modify but could well be perpetual battleships. Multiyear timeframes were typical not merely in program development and also in producing and other business functions. But waterfall’s rigidity became an Achilles heel in the world wide web period, where speed and flexibility ended up required. (Source)

Software advancement methodology commenced to change when developers began focusing on World wide web programs. A lot of the early operate was performed (Reference) at startups the place groups were being more compact, were being colocated, and infrequently did not have standard computer science backgrounds. There were financial and competitive pressures to bring websites, applications, and new abilities to current market quicker. The event resources and platforms improved speedily in response.

This led many of us Doing the job in startups to problem waterfall methodology and to search for approaches to be much more successful. We couldn’t pay for to try and do each of the thorough documentation up front, and we needed a far more iterative and collaborative procedure. We still debated modifications to the necessities, but we had been more open up to experimentation and to adapting to finish-user wants. Our corporations were being considerably less structured and our applications have been much less advanced than organization legacy programs, so we were being a lot more open to developing vs . buying programs. Extra importantly, we had been looking to increase enterprises, so when our buyers explained to us anything wasn’t working, we more often than not chose to hear them.

Our capabilities and our capabilities to innovate turned strategically vital. You might raise all the money you desired, but you couldn’t appeal to talented software program builders able to operate with fast transforming internet technologies if you had been likely to take care of them as subservient coders slavishly next “the spec.” We rejected job supervisors coming in with close-to-close schedules describing what we should establish, when applications should really ship, and occasionally even the best way to structure the code. We were horrible at hitting the 3-month and six-thirty day period schedules that the waterfall task managers drafted and unceasingly up to date. https://pm.mba/posts/waterfall-vs-agile/

As a substitute, we began to tell them how internet apps needed to be engineered, and we delivered final results on a program that we drew up iteratively. It seems we weren’t that terrible at providing what we reported we'd once we devoted to it in small, a single-7 days to four-7 days intervals.

In 2001, a gaggle of expert software package developers obtained alongside one another and recognized they have been collectively training software package development in another way within the classical waterfall methodology. They usually weren’t all in startups. This team, which integrated technological know-how luminaries Kent Beck, Martin Fowler, Ron Jeffries, Ken Schwaber, and Jeff Sutherland, arrived up Together with the Agile Manifesto that documented their shared beliefs in how a contemporary computer software advancement method should really function. They stressed collaboration over documentation, self- Business rather than rigid management practices, and the ability to manage to regular modify as opposed to lock oneself to some rigid waterfall improvement system. [Reference]

From People ideas was born the agile methodology for software program enhancement.

youtube

#agile #scrum #management #projects

0 notes

t-baba · 5 years ago

Photo

React's rise, Babel 7.10.0, and good GitHub etiquette

#491 — June 5, 2020

Unsubscribe | Read on the Web

JavaScript Weekly

Grid.js: An Advanced Table Library — A lightweight, advanced table plugin that can work alongside React, Angular, Vue, or, well, nothing. Check out some of the examples for more on how to use it. It uses Preact under the hood.

Afshin Mehrabani

The Rise of React (And Its Growing Pervasiveness) — In the most recent issue of Increment, a noted journalist (for WIRED and The Economist) takes a wide-angle look at how React came to be one of the predominant frontend frameworks powering today’s web and the attendant implications ― both positive and negative ― for the future.

Chris Stokel-Walker (Increment)

Does a Serverless Headless CMS Exist? It Does Now — The first headless CMS built for serverless infrastructure. Forget about scaling problems, flash crowds, setting up and managing servers and stop overpaying for resources you don't use. It's free and open-source, check it out.

Webiny sponsor

Babel 7.10.0 Released — The hugely popular JavaScript transpiler got more tweaks than you’d expect for a minor point release including an experimental version of a new polyfills compatability architecture, improvements to optional chaining and private fields support, and better tree-shaking for React code.

Nicolò Ribaudo

⚡️ Quick bytes:

🖤 This week, the React core team joined the Facebook employee walkout in solidarity with the Black community — it's time to speak up, donate or even just stream a fundraising video, because Black lives matter.

The Repl.IT online IDE/sandbox now supports Deno if you want to play without installing it for real.

SpiderMonkey, Firefox's JavaScript engine, has a new regular expressions engine which opens up support for modern regex syntax it didn't have before.

AngularJS 1.8.0 is out. Yes, that's the old school Angular.js, not the more modern Angular.

Zappar has released some universal AR SDKs for Three.js and vanilla JavaScript if augmented reality is your bag.

💻 Jobs

JavaScript Developer at X-Team (Remote) — Join X-Team and work on projects for companies like Riot Games, FOX, Coinbase, and more. Work from anywhere.

X-Team

Find A Job Through Vettery — Vettery specializes in tech roles and is completely free for job seekers. Create a profile to get started.

Vettery

Senior Software Engineer — Save Lives & Make an Impact — We use Node/TS/React & ML to provide crisis support via SMS. Help us scale globally with a focus on privacy and security.

Crisis Text Line

📚 Tutorials and Opinions

Reusing UI Components at Enterprise Level — An engineer at PayPal explains how they share UI components across their various products.

Dong Chen (PayPal)

The 'Top Types' any and unknown in TypeScript — They’re not top types because they’re the best types 😂 .. but they’re essentially ‘universal’ types that can contain all values (in opposition to the never type which is the empty set).

Dr. Axel Rauschmayer

One Cool Trick to Simplify Reducer Functions — An introduction to the Immer immutable state library as a way to reduce the complexity of Redux reducers.

Eric Elliott

Getting Started With OpenTelemetry In Node.js

Lightstep sponsor

How-to Normalize Home Volume Levels with Node-RED — Node-RED is a JavaScript-powered ‘low code’ visual programming environment frequently used with hardware/IoT use cases. I rarely see tutorials about it, so this is pretty neat.

Blake Niemyjski

The Service Worker Lifecycle Explained — Explaining the lifecycle of Service Workers in PWAs and how to update them as fast as possible.

Felix Gerschau

Track Your (Android) Smartphone in Physical Space with JavaScript — Leans on the Generic Sensor APIs so you’re limited to Android for now, but it’s fun to see the potential.

Sanjeet Chatterjee

Some Reminders of Good GitHub Etiquette — Basic things, but sometimes easily forgotten, from one of the date-fns maintainers.

Sasha Koss

MongoDB Is Easy. Now Make It Powerful. Free Download for 30 Days.

Studio 3T sponsor

▶ Inside Vue 3 with Gregg Pollack — An hour long podcast chat with Gregg Pollack of Vue Mastery about Vue 3 reactivity model course and when and where the new Composition API is worth using.

Views on Vue Podcast podcast

How to Create a Web Worker-Driven Multithreaded Frontend App — It leans on an under-development Web Worker-driven framework called neo.mjs that promises “a new era of making better Web-based user interfaces.”

Tobias Uhlig

Stranger Things, JavaScript Edition — This is mostly a bit of fun mixed with a little bit of Wat picking on some JavaScript oddities. If the quirks of equality and NaN are familiar to you, move on.

Live Code Stream

Using Git to Run ESLint on Changed Files in a Feature Branch

Jeffrey Auriemma

🔧 Code & Tools

TUI Editor 2.1: A Powerful Markdown WYSIWYG Editor — You get the Markdown on the left, output on the right. The latest release added much better syntax highlighting for the Markdown source (if you want it) and ‘preview highlighting’ where the output of the code you’re working on is highlighted in the preview pane.

NHN

redaxios: The Axios API, as an 800 Byte Fetch Wrapper — If you love the Axios API but want to get it in a lighter way..

Jason Miller

A Much Faster Way to Debug Code Than with Breakpoints or console.log — Move forward and backwards through your code to understand what led to a specific bug, view runtime values, edit-and-continue, and more.

Wallaby.js sponsor

React Date Picker 3.0: A Simple and Reusable Date-Picker Component — A mature option that continues to get frequent updates. Demo here.

HackerOne

Frappe Charts 1.5: Responsive, Zero Dependency SVG Charts — Here’s are some examples (with code) to explore.

Prateeksha Singh

ms: Tiny Milisecond Conversion Utility — For example: ms('2.5 hrs') becomes 9000000 .. or ms(2 * 60000) becomes ‘2m’.

Vercel

🗓 Upcoming Online Events

JS Nation (June 18-19) — This free two-day remote conference features over 25 speakers, including Jen Looper, Max Stoiber, John Papa and others.

OpenJS World (June 23-24) — Speakers at this 'virtual experience' include Nicole Sullivan, Prosper Otemuyiwa, Cassidy Williams and more.

CascadiaJS 2020 (September 1-2) — This upcoming online conference is set to take place in September.

by via JavaScript Weekly https://ift.tt/2XyWzFv

#Javascript Branding #Javascript Weekly

0 notes