stealify / legacy-1-stealify-contains-bad-justjs-zerojs-stuff Goto Github PK

Stealify Lang - compiles down to JavaScript / ECMAScript 2022

Home Page: https://stealify.github.io/stealify

License: Apache License 2.0

JavaScript 74.61% HTML 0.22% Dockerfile 0.10% Roff 0.08% Makefile 2.97% Assembly 0.14% Shell 0.12% C++ 21.43% C 0.24% Python 0.01% PEG.js 0.08%

java rust javascript runtime stealify stealify-lang chromiumos chromium

legacy-1-stealify-contains-bad-justjs-zerojs-stuff's Introduction

legacy-1-stealify-contains-bad-justjs-zerojs-stuff's People

Contributors

Stargazers

Watchers

Forkers

frank-dspeed ets-reactnative1

legacy-1-stealify-contains-bad-justjs-zerojs-stuff's Issues

Introduce Euler

Project Euler, ftw!
If you solve the first 50–100 Project Euler problems you will:
https://projecteuler.net/
Have a solid command of programming fundamentals
Be confident and fluent in the syntax of your chosen language
Learn about algorithm optimization, and — more importantly — optimization intuition
Gain experience writing clean code with good documentation
Have an opportunity to practice test-driven development
Have something impressive to show on your GitHub and portfolio
I don’t know of any other set of problems that’s as well suited to teach and demonstrate your command of programming fundamentals. Project Euler is a must-do for any developer or aspiring developer.

The War of Bundlers

At Present there are 2 Valid Bundlers out there

StealJS => creates CJS SystemJS Compatible bundles and has a ecosystem
RollupJS => creates ESM Bundels and can be also used to create CJS

The Current Strategy should be to use both if your targeting CJS and then later Switch to rollup as soon as its ecosystem got big enough.

Implament pauseless gc inside JVM

https://openjdk.java.net/jeps/318
https://shipilev.net/jvm/diy-gc/
There's an interface called JVMCI that Graal plugs into that those JVMs could implement if they wanted. You'd then have to implement some things in Graal to support the new JVM, like object layout and GC guards. It's up to the people who make the other JVMs to implement JVMCI if they want to

Stealify Installer

Should use docker
https://github.com/weaveworks/ignite

Introduce Cross Plattform Nativ Applications

Favorit Reason

OCaml. Reason's just a syntax and toolchain layer on top of OCaml. The OCaml<->Reason interop should be seamless since we share the same abstract syntax tree. BuckleScript works fine in OCaml, naturally. Js_of_ocaml too.
Rust. Close cousin of ours. Not garbage collected, focused on speed & safety.
Elm. Another cousin of ours! Make clean, fun webapps.
PureScript. Inspired by Haskell, compiles to the web.
Fable. Based on F#, which is closely related to OCaml.
ClojureScript. Nothing in common with us on the surface, but prioritizes simplicity & great interop too.
Swift. Fruit-flavored OCaml!
Haxe. Compiles to basically anything.

What is It?

Is it a Highly scalable realtime framework ?

Yes! for NodeJS, GraalJS, embedded IoT, and the Browsers

is it an ENTERPRISE-CLASS, MULTICLOUD TO EDGE NOSQL DATABASE?

Yes! Develop with agility. Perform at any scale. Manage with ease.

Develop with agility

Time to market is critical, separating the first mover from everyone else. Developing an application today without knowing all of its needs at the outset requires a database that provides flexibility in schema and access patterns that empowers developers to build responsive, flexible applications at scale.

Distributed Computing and Machine Learning
Couchbase like multi node cluster wide eventing https://docs.couchbase.com/server/6.0/eventing/eventing-overview.html
Flexible schema for continuous delivery
Fully featured SQL for JSON database
No hassle scale out

# understand promise execution

Hi.
I have a question about Promises
for example I have

async function main() {
    await interopUtil.createPromise();
}

where interopItil.createPromise()  do:
    public Object createPromise() {
        return (Thenable) (resolve, reject) ->
            scheduler
                .doOnNext(resolve::executeVoid)
                .doOnError(reject::executeVoid)
                .subscribe();
    }
    public interface Thenable {
        void then(Value resolve, Value reject);
    }

//After that. In another Java code part I do:
                Value promise = context.getBindings("js")
                    .getMember("main")
                    .execute(); // promise object created, but not executed.
                promise.getMember("then").executeVoid(
                    (Consumer<Object>) sink::success,
                    (Consumer<Object>) sink::error
                ); /// promise object executed

Why when I create Promise through calling async function main , result Promise didn't executed?
Looks like by spec, if JS stack is empty, Promise callback will be executed?
With then that works.

6 Antworten

Daniele Bonetta vor 12 Stunden
Yes, the JS spec says that the engine should execute the promise callbacks when the JS stack is empty. This is what we do in Java+JavaScript interop: we execute JS promise callbacks when we return to Java (and the JS stack is really empty) (bearbeitet)

Daniele Bonetta vor 12 Stunden
So in your code, main should be executed and then be suspended at await -- I am not sure what your scheduler object does, though

Daniele Bonetta vor 12 Stunden
could you perhaps create a github issue with a small unit test describing the execution behavior you would expect?

Daniil Mikhaylov vor 12 Stunden
Thanks. scheduler put task to Netty's event loop queue through Reactor API. So this code is non-blocking.
Execution behavior is perfect. I glad to find out that in Graal.js I can execute my Promise chain later.
I dig a little bit in your tests, looks like this behavior can be configured through this option https://github.com/graalvm/graaljs/blob/master/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSContextOptions.java#L415
My question is more about architectural purposes.
So if call then it's just continue flushing job queue? (bearbeitet)

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSContextOptions.java:415

    public static final String INTEROP_COMPLETE_PROMISES_NAME = JS_OPTION_PREFIX + "interop-complete-promises";
<https://github.com/graalvm/graaljs|graalvm/graaljs>graalvm/graaljs | Hinzugefügt von GitHub

Daniele Bonetta vor 12 Stunden
Yes, calling then registers a new callback in the promise reactions job, and the callback is executed later when the promise resolves
👌
1

Daniele Bonetta vor 12 Stunden
that INTEROP_COMPLETE_PROMISES_NAME option is non-standard, and simply "forces" promise resolution; it's disabled by default, but can be used e.g. when you are 100% sure that your interop call will return a promise that is not pending -- in general, I would suggest to leave that option disabled and use then chains wherever possible

# How to Deploy Kubernetes

kops
minikube --docker
rancher
stealify-k8s

Write about po.et

https://www.po.et/

Address Packaging

Self Contained Packaging

Java https://docs.oracle.com/javase/8/docs/technotes/guides/deploy/self-contained-packaging.html
JavaScript

Let Express apps listen on a Random port and expose that port

app = express();
server = http.createServer(app).listen();
app.set('port', server.address().port);

Create a Helper That allows to create systemd unit files more easy

[Service]
ExecStart=/usr/bin/node /srv/drivers/custom-tl80-printer/index.js
WorkingDirectory=/srv/drivers/custom-tl80-printer/
Restart=always
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=printer
User=root
Group=root
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target

PHP Support

We Could need better PHP Interop support we are working on that via graalphp

current way is to use JPHP or Usage of a external php-fpm or cgi implamentation.

# Monitor a Cluster via grafana

Grafana can run mysql querys on Stealify
Stealify can log to prometheus and grafana can pick up there
Stealify can be used to deploy grafana with unlimited storage that scales.

# Expect No Mercy Rayn Dahl there is No Regret!

The goal of Node was event driven HTTP servers.

5:04
1 Regret: Not sticking with Promises.

I added promises to Node in June 2009 but foolishly removed them in February 2010.
Promises are the necessary abstraction for async/await.
It's possible unified usage of promises in Node would have sped the delivery of the eventual standartization and async/await.
Today Node's many async APIs are aging baldly due to this.

6:02
2 Regret: Security

V8 by itself is a very good security sandbox
Had I put more thought into how that could be maintained for certain applications, Node could have had some nice security guarantees not available in any other language.
Example: Your linter shouldn't get complete access to your computer and network.

7:01
3 Regret: The Build System (GYP)

Build systems are very difficult and very important.
V8 (via Chrome) started using GYP and I switched Node over in tow.
Later Chrome dropped GYP for GN. Leaving Node the sole GYP user.
GYP is not an ugly internal interface either - it is exposed to anyone who's trying to bind to V8.
It's an awful experience for users. It's this non-JSON, Python adaptation of JSON.
The continued usage of GYP is the probably largest failure of Node core.
Instead of guiding users to write C++ bindings to V8, I should have provided a core foreign function interface (FFI)
Many people, early on, suggested moving to an FFI (namely Cantrill) and regrettably I ignored them.
(And I am extremely displeased that libuv adopted autotools.)

9:52
4 Regret: package.json

Isaac, in NPM, invented package.json (for the most part)
But I sanctioned it by allowing Nod's require() to inspect package.json files for "main"
Ultimately I included NPM in the Node distribution, which much made it the defacto standard.
It's unfortunate that there is centralized (privately controlled even) repository for modules.
Allowing package.json gave rise to the concept of a "module" as a directory of files.
This is no a stictly necessary abstraction - and one that doesn't exist on the web.
package.json now includes all sorts of unnecessary information. License? Repository? Description? It's boilerplate noise.
If only relative files and URLs were used when importing, the path defines the version. There is no need to list dependencies.

12:35
5 Regret: node_modules

It massively complicates the module resolution algorithm.
vendored-by-default has good intentios, but in practice just using $NODE_PATH wouldn't have precluded that.
Deviates greatly from browser semantics
It's my fault and I'm very sorry.
Unfortunately it's impossible to undo now.

14:00
6 Regret: require("module") without the extension ".js"

Needlessly less explicit.
Not how browser javascript works. You cannot omit the ".js" in a script tag src attribute.
The module loader has to query the file system at multiple locations trying to guess what the user intended.

14:40
7 Regret: index.js

I thought it was cute, because there was index.html
It needlessly complicated the module loading system.
It became especially unnecessary after require supported package.json

How is all that addressed inside Stealify

debugging

event

occesinal connected clients
linear

Documentation:

Use of Rollup in the Browser as Loader and on the Client as bundler. make some examples of this with esm-loader.

// rollup-plugin-my-example.js
export default function myExample () {
  return {
    name: 'my-example', // this name will show up in warnings and errors
    resolveId ( source ) {
      if (source === 'virtual-module') {
        return source; // this signals that rollup should not ask other plugins or check the file system to find this id
      }
      return null; // other ids should be handled as usually
    },
    load ( id ) {
      if (id === 'virtual-module') {
        return 'export default "This is virtual!"'; // the source code for "virtual-module"
      }
      return null; // other ids should be handled as usually
    }
  };
}

// rollup.config.js
import myExample from './rollup-plugin-my-example.js';
export default ({
  input: 'virtual-module', // resolved by our plugin
  plugins: [myExample()],
  output: [{
    file: 'bundle.js',
    format: 'esm'
  }]
});

First Release Should be OpenStack Based

Nova, Glance, Swift, Horizon, Keystone, Neutron, Cinder, Heat, Ceilometer, Trove, Sahara, Ironic, Zaqar, Manila, Designate, Barbican, Searchlight, Magnum, aodh, cloudkitty, congress, freezer, mistral, monasca-api, monasca-log-api, murano, octavia, panko, senlin, solum, tacker, tricircle, vitrage, Watcher, zun

but we will integrate directly with rumpkernl and capsan

Ecosystem News: Feb 2020

We Welcome GraalVM to the ESModule Ecosystem

It allows you to build high performance JS Applications including bridging to 28 more languages.

see the es4x project and vertx projects for more infos

Stop Collection of backlog documentation related

Rewrite conclusion of all issues.

Proposal: parse a string as DOM

es-dom-sdk

A Software Development Kit Framework or Collection of usefull methods to create a Document Object Model Representation from a String and Serialize that Model Back to a String.

parse5
cheerio
htmlparser2
any....

https://github.com/stealify/es-dom-sdk

Write a Book about Garbage Collectors in Java

Here we put in all from the GC Effort and maybe start new issues to implament the

no gc monitor restart realtime algo.

Create a NodeJS + Apache Ignite Guide + Deployment

We want to have a easy stealify-code-server

Explain how gc works

outside of c or asm never do finalizing like nulling references! in JS you need to eventually clean up your listneres if you use some that can not clean up them self via unregistering if source does not exist.

# Explain serverless functions.

serverless functions are about the concept of running and tracking a single function at scale executed on an event.

you can code and run short running serverless functions with Stealify as it produces a single binary that has a really fast startup time.

you can code and run long-running serverless functions at a scale and efficiency that is unparalleled to any serverless framework as you can build your application and abstract the framework away.

Serverless Applications

Serverless Applications are like serverless functions that are most time long running the main goal is to bundle many serverless functions into a serverless application to reduce the network overhead and problems.

In-Memory Computing Essentials for Software Engineers

fundamental capabilities of in-memory computing platforms that are proven to boost application performance and solve scalability problems by storing and processing unlimited data sets distributed across a cluster of interconnected machines.

The session is tailored for software engineers and architects seeking practical experience with in-memory computing technologies. You'll be given an overview (including code samples in Java) of in-memory concepts such as caches, databases, and data grids combined with a technical deep-dive based on Apache Ignite in-memory computing platform. In particular, we'll cover the following essentials of distributed in-memory systems:

Data partitioning: utilizing all memory and CPU resources of the cluster
Affinity co-location: avoiding data shuffling over the network and using highly-performant distributed SQL queries
Co-located processing: eliminating network impact on the performance of our applications

# Machine Learning 101

generic distributed coding with ignite

https://www.gridgain.com/resources/blog/genetic-algorithms-apacher-ignitetm

intro machine learning

https://www.gridgain.com/resources/blog/introduction-machine-learning-apacher-ignitetm

Fraud Detection

https://dzone.com/articles/using-apache-ignites-machine-learning-for-fraud-de

k-means algo, linear regresion, k-nn

TODO: Expand STYLEGUIDE_JS

Add Section about ES6/7 CJS
Clarify why to use CJS Only at Present.

How to decrement code

Often we talk about incremental code evolution we should consider more often decrementing code
reducing dependencies here are some strategies that are efficient in the ECMAScript world.

rollup into a single ES version and export from that what you need this can be done via rollup and can be fine-tuned via it also till you end up in code that is only maintained by you.

You will ask why should I want to maintain code? It is a part of your app you are responsible for all your dependencies anyway research and followup are most time more expensive than own maintained code.

research

https://quarkus.io/

vertx serialport

https://github.com/cpriisholm/vertx-serial-port-logger

We would need a good Java Implamentation for serial ports.

Introduce intersection observe lazy loading

<div>
  <p>SCROLL DOWN FOR IMAGE</p>
  <p>some content 15</p>
  <p>some content 14</p>
  <p>some content 13</p>
  <p>some content 12</p>
  <p>some content 11</p>
  <p>some content 10</p>
  <p>some content 9</p>
  <p>some content 8</p>
  <p>some content 7</p>
  <p>some content 6</p>
  <p>some content 5</p>
  <p>some content 4</p>
  <p>some content 3</p>
  <p>some content 2</p>
  <p>some content 1</p>
  <div id="app"></div>  
</div>

.container {
  border: 1px solid black;
  height: 300px;
  overflow: auto;
}

	connectionCallback() {
    this.observer = new IntersectionObserver(
      entries => {
        entries.forEach(entry => {
          const { isIntersecting } = entry;

          if (isIntersecting) {
            this.element.src = this.props.src;
            this.observer = this.observer.disconnect();
          }
        });
      },
      {
      	root: document.querySelector(".container"),
        rootMargin: "0px 0px 200px 0px"
      }
    );

    this.observer.observe(this.element);
  }

  view() {
    <img ref="placehoder" />;
  }
}

ReactDOM.render(<Image src="https://via.placeholder.com/300x300" />, document.querySelector("#app"));

Stealify 1.5 - CHOPPER

graalphp support oracle/graal#361 (comment)

Stealify 3.0 - PARADOX

Roadmap for the Paradox Release

This is a planned under the assumption that the rust ecosystem will become more complet and interop will get better else this will be in Java Still.

The Paradox Release will be using a Large Rust Ecosystem and is expected in round about 10 years from now on. It Will Probally export a mix of ignite coded in rust, atomx, vertx (Java) actix (Rust) wax (wasm)

vertx => actix
wax

Stealify 2.0 - REiDEEN

It is an Amazing Release I can not find the right words to describe the impact that this has to the overall Coding Community.

New NodeJS node.h rewrite using Java
better asm.js (Optimized ECMAScript)
better wasm support
better Programing Language Interoperability with less overhead.
- JavaScript / ECMAScript2020 / ES20
- Rust
- Java
- C
- Python
- Ruby
- Go

Finally we Got what we Call Unikernels

Substrate VM is a framework that allows ahead-of-time (AOT) compilation of Java applications under closed-world assumptions into executable images or shared objects (ELF-64 or 64-bit Mach-O).

and as our new Runtime is written in Java that means we can Optimize Finally the Whole Stack including NodeJS or lets Better call it GraalJS which is NodeJS Compatible.

# Low pause gc

https://wiki.openjdk.java.net/display/shenandoah/Main

Stealify Theia & vscode & Code server tooling and support.

Successor of the COLA-Project

The Cola Project

Project COLA is an Innovation Action funded by the European Commission as part of the Horizon2020 Programme. The COLA project started in January 2017 and will last 30 months. The consortium includes 10 companies and 4 research organizations from 6 European countries, including the United Kingdom, Hungary, Sweden, Switzerland, Spain, and Germany. The coordinator of the COLA project is Dr. Tamas Kiss, University of Westminster (UK).

Why?

SMEs and public sector organizations increasingly investigate the possibilities to use cloud computing services in their everyday business conduct. Accessing services and resources in the cloud on-demand and in a flexible and elastic way could result in significant cost savings due to more efficient and convenient resource utilization that also replaces large investment costs with long term operational costs. On the other hand, the take up of cloud computing by SMEs and the public sector is still relatively low due to limited application-level flexibility and also security concerns.

How? Project COLA (Cloud Orchestration at the Level of Application)

aims to increase the adoption of cloud computing services by the above mentioned two strategic target communities. Typical industry and public sector applications require resource scalability and efficient resource utilization in order to serve a variable number of customers with dynamic resource demands, and to suitably optimize resource consumption and costs. However, the dynamic and intelligent utilization of cloud infrastructure resources from the perspective of cloud applications is not trivial. Although there have been several efforts to support the intelligent and coordinated deployment, and to a smaller extent also the run-time orchestration of cloud applications, no comprehensive solution has emerged until now that could be applied in large scale near operational level industry trials.

Overall Objective.

The overall objective of the COLA project is that by building on and extending current research results, it will define and provide a reference implementation of a generic and pluggable framework (the MiCADO framework) that supports the optimal and secure deployment and run-time orchestration of cloud applications. COLA will demonstrate the applicability and impact of the solution via a large scale near operational level SME and public sector pilots and demonstrators, and will also define a clear pathway how the innovation can be delivered to the market.

Stealify as Successor

Current State 2020 of the COLA-Project is that they coded some ansible and other scripts to explore generic cloud configuration as the cloud is moving faster as they could adopt that makes total no sense.

List of Cons:

Not every provider offers the same services
API Changes frequently
The coder needs to learn a new framework while he is probably familiar with the cloud API's themself.

How we are a Successor?

We give your Application direct control over the scaling via the nativ frameworks of your Cloud providers this way you can control and fast deploy IAC Infrastructure as Code.

Example Application Scaling based on Application Metrics

Scale on CPU Usage of a Single Instance
Scale on Cluster Usage
Scale on Anything or PREFORK Optimistic.

# Getting Graphs from Graal Nodes

# Getting Graphs
## GraalVM Compiler as a Java compiler
`-Dgraal.Dump=:2` is a simple option to enable Graal graph dumping.
The value of `Dump` is a *dump filter*. The format of dump filters is
[documented][dump-filters], but in simple cases `:2` will be enough and will
give you everything.
[dump-filters]: https://github.com/oracle/graal/blob/master/compiler/src/org.graalvm.compiler.debug/src/org/graalvm/compiler/debug/doc-files/DumpHelp.txt
You may want to combine with `-XX:CompileOnly=Foo::foo` (you can omit the class
part) to restrict  compilation to a single method to give smaller dumps, and to
some extent make graphs simpler by avoiding what you want to look at being
inlined, or other things being inlined into it.
Graal tends to be quite aggressive about loop unrolling, which can produce
massive graphs with the logic repeated. I often use these flags to simplify the
graph without significantly effecting too much how the logic in it is compiled.

  -Dgraal.FullUnroll=false \
  -Dgraal.PartialUnroll=false \
  -Dgraal.LoopPeeling=false \
  -Dgraal.LoopUnswitch=false \
  -Dgraal.OptLoopTransform=false \
  -Dgraal.OptScheduleOutOfLoops=false \
  -Dgraal.VectorizeLoops=false

About Modules

Stealify only works with modules but don't get shoked by that fact it offers a strong api to produce modules out of any source this is also the method you will use to adopt aka stealify your project dependencys

You should follow the how to adopt JS Software guide
and if you need to adopt something diffrent you need the adopt anything to ESM guide,

# Was macht Stealify so Intressant

The Idea

ich musste oft Server Anwendungen entwickeln die automatisch skalierbar sein sollten. Fehler Tolerant, Selbstheilend, Administrationsaufwand sollte klar ein minimum sein am besten installieren und vergessen.

Viele firmen und kunden kennen es noch das man einen Apache WebServer Installiert eine Webseite hoch lädt und das läuft dann 15 Jahre am stück durch ohne Probleme auf 15 Jahre alter Hardware.

Das trifft auch heute noch zu doch das ist einfach nicht mehr die art von Software die wir betreiben und betreiben wollen. Wir brauchen heute Echtzeit Auswertung, Monitoring, AI Entscheidungen, Rechteverwaltung, Security und vieles mehr. Das alles nicht nur für 3 User sondern am besten Millionen .

Wir sehen schnell der Apache Webserver musste viel weniger Zugriffe verarbeiten bei der Verarbeitung auch viel weniger leisten und er speichert auch viel weniger Daten.

100 Gleichzeitige User über 1 std in einer Geschäftlich genutzten Application mit Microservices Design erzeugen mehr Daten insgesamt als 100000 normale Request zum besagten alten Apache Webserver.

Das führt uns zum entstehen von Cloud Angeboten die es ermöglichen mit geringerem Aufwand Alte Applikationen mit den neuen Anforderungen auszuführen und schneller neue Anwendungen bereit zu stellen welche die neuen Anforderungen erfüllen.

Es Handelt sich dabei um installierte standartisierte managed software lösungen.

Stealify integriert alle diese standartisierten anforderungen und stellt managment lösungen zur verfügung. Stealify ist Praktisch ihr eigener Cloud Anbieter sie müssen ihm nur die Hardware geben dafür stehen verschiedene wege zur verfügung.

Stealify Concepts

Wir Bündeln alles was für eine Skalierbare Hoch Leistungs Anwendung nötig ist in unsere Software direkt und erlauben es diese flexibel zu configurieren zb können sie auf einem server alle services ausführen aber auf einem anderen zb nur einen. Das ermöglicht horizontales und verticales Skalieren.

durch das bündeln der Kritischen Komponenten kann sichergestellt werden das immer alles gemeinsam mit einander Harmoniert.

Zum beispiel das erste was Sie machen wenn Sie eine anwendung erstellen ist sich zu fragen welche datenbank installiere ich.
Danach werden Sie sich fragen wie krieg ich mehr leistung das ist zu langsam
Danach werden Sie sagen ah Caching ist die lösung.
Danach beginnt es richtig kompliziert zu werden

Stealify wird direkt mit der besten in memory distributed cache und datenbank lösung ausgeliefert
Momentan Apache Ignite es kann aber auch einfach nicht genutzt werden.

Doch das sieht und weiß der kunde das nicht unbedingt.

# Research java vs c++

The only problem is that the Hotspot JIT still uses a method JIT. Method JITs are limited to optimising on a method-per-method basis, so more aggressive allocation optimisations are not really possible (without expensive interprocedural analysis, or without exploding the generated machine code, which would be pretty bad in modern architectures). The Graal compiler is a tracing JIT instead, which is not limited to optimising a single method at a time. Allocation sinking[5] works pretty nicely on top of such JIT, and can get rid of all temporary allocations in a trace.

In short:

C++ gives you more control over and more tools to work with memory, so you can spend your precious development time manually optimising your programs. You pay a huge price upfront for this control in C++[6] , since unlike ATS[7] the language isn’t memory safe;
Java takes control away from you, some of this is what enables the implementation to heavily optimise common cases for you. That is, unoptimised Java will most likely be more efficient in memory usage than unoptimised C++. You get much better performance without having to pay as much in development costs. However, as soon as you need to optimise memory (i.e.: after profiling and finding out that allocation is a bottleneck), you have a problem. It’s going to be possible, but the language won’t help you.

https://www.azul.com/resources/azul-technology/azul-c4-garbage-collector/

While it’s about JavaScript and Rust, most of it applies to Java and C++: Maybe you don't need Rust and WASM to speed up your JS
https://mrale.ph/blog/2018/02/03/maybe-you-dont-need-rust-to-speed-up-your-js.html

[1] The Azul C4 garbage collector from Azul Systems Inc.

[2] Richard Jones @ VMSS16: Building High Performance, Fully Concurrent Garbage Collectors

[3] Main - Shenandoah - OpenJDK Wiki

[4] A Crash Course in Modern Hardware by Cliff Click

[5] Allocation Sinking Optimization

[6] It's time for a memory safety intervention • Tony Arcieri

[7] ATS-PL-SYS

https://www.quora.com/Is-Java-faster-than-C-without-Garbage-Collection

Opportunities for You

Get a chance to apply your skills and knowledge to solve complex computer problems
Contribute to an open-source technology with contributors and users all over the world
Work in a distributed self-driven international team
Gain invaluable experience in what it is like to work at a leading global hardware and software systems innovators
Learn from the colleagues who are industry experts and scientists as also leaders and talkers

Given the broad range of opportunities, specific skills will depend on the specific topic. In general, if you can tick several of the following skills, we probably have a place for you:

Strong Java programming knowledge (required)
Fluent English communication (required)
Experience with compiler technology
Node.js developer experience
Browser API and Compatibility knowledge and understanding.
Programming experience in one or more of the following languages:
- JavaScript
- Python
- Ruby
- R
- C/C++
- Go
- Rust
- WASM

Stealify UI needs a Replacement for Electron

https://bitbucket.org/chromiumembedded/java-cef/src/master/
This will enable graaljs to run desktop applications.

stealify / legacy-1-stealify-contains-bad-justjs-zerojs-stuff Goto Github PK

legacy-1-stealify-contains-bad-justjs-zerojs-stuff's Introduction

Stealify Lang

Release Plans

Tooling

Stealify Academy

language-integration-tooling

Stealify lower the barrier of using v8::Isolates

Stealify should get a Collection of Tooling Best Practices to Create and Compose Software with ECMAScript glue Code

Most Current Stack

About NodeJS

About GraalVM

About Rust

Stealify Incubator for @direktspeed/vmpack & vmdeploy & @open-pwa

Stack

Some examplesExtras

TODO:

Internals Roadmap

Stealify build on the Sholders of Giants

Core Components

Core Integration Points for JS / ES / Javascript / ECMAScript

WASM + WASi + WASMVM(Runtime)

GraalVM Runtime

Why ECMAScript / ES6+ / Javascript / Node is focused?

a Comic Description

Patterns

Short Why?

Stealify the Software encapsulation Framework Concept

What is It for?

What is It not for?

What is it more exactly?

How it Works?

Examples

The Core Stealify Components

Get it?

Example usecases

Anti Patterns

TODO