ferocity
TypeScript
ferocity | TypeScript | |
---|---|---|
7 | 1,319 | |
6 | 98,551 | |
- | 0.6% | |
2.6 | 9.9 | |
about 2 years ago | 7 days ago | |
Java | TypeScript | |
- | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
ferocity
-
Java JEP 461: Stream Gatherers
The advantage of the static import DSL is that it is more composable: anyone else can define operators that interoperate with my operators without the complexity of the scheme linked above not to mention more generality. This goes not just for the low level operators like "filter" that you might want to supplement but the many more operators you can write that are implemented out of mine.
I prototyped an API that works in the same direction as streams by having something like
https://paulhoule.github.io/pidove/apidocs/com/ontology2/pid...
in that it wraps all Iterables returned by my methods and has not just the teardown facility but also all the operators attached as instance methods which lets you write the chaining style you ask for that I know is in demand.
If I was going to go any further on pidove it would have involved more use of code generation and this system
https://github.com/paulhoule/ferocity
which was supposed to be a code generator for writing code generators, and it could code generate stubs that would let you write expression trees in Java as S-expressions and build them up into methods and either compile the code to real Java source code or execute the methods by evaluating the expression tree in place.
Like common LISP you can write syntactic macros in that that metalanguage because an Expression> can be evaluated at compile time, one of quite a few concepts like "quoting" that I encountered in that spike.
The idea was ferocity would get to the point where it synthesizes a more complete and perfect pidove.
-
TypeScript please give us types
but you can't have an overload that takes two differently parameterized expressions, this lets you write Java code in a lisp-like syntax that can be metaprogrammed on:
https://github.com/paulhoule/ferocity/blob/main/ferocity-std...
that project got me thinking a lot about the various ways types manifest in Java and I made the discovery that when you add Expression types you practically discover an extended type systems where there are many things that are implied by the existence of ordinary Java types.
-
Overinspired?
I find this alien to my point of view. On the other hand, my side projects aren't driven by FOMO but are more like the "special interests" of autistic people.
Most of the time I have three side projects going on, maybe two of which are really getting the attention they deserve and one that is languishing. (See my profile to see about my current three.) Occasionally I get inspired to spend 1-4 weekends on some sudden inspiration, of which
https://github.com/paulhoule/pidove
came to completion but
https://github.com/paulhoule/ferocity
probably won't. The project I'm working the hardest on now is something that I was baffled that it didn't exist 18 years ago but felt compelled to do something out because of the Twitterinsanity last December and it turned out the technological conditions right now make it the perfect time to work on.
-
Typed Lisp, a primer (2019)
I have hacked off and on on this
https://github.com/paulhoule/ferocity
which lets you write extended Java in a lispy syntax. It generates stubs for the standard library and other packages you choose, unerasing types by putting them into method names. It works pretty well with IDEs but there are still problems w/ type erasure such that some kinds of type checking can't be done by the compiler working directly on the lispy Java, probably I wouldn't implement newer features such as pattern matching that are dependent on type inference to work, though lambda definitions are feasible if you give specific types.
The 'extended' bit was almost discovered instead of invented in that it is pretty obvious that you need quote and eval functions such that you can write lispy Java programs that manipulate Java expressions. Said expressions can be evaled at runtime with a primitive interpreter or incorporated into classes that are compiled w/ Javac. The motivation of the thing was to demonstrate Java-embedded-in-Java (an ugly kind of homoiconicity) and implement syntactic macros from Java which I think that prototype proves is possible but there is a lot more to be done on it to be really useful. Enough has been implemented in it right now in that you can use it to write the code generator that builds stubs. It might be good for balls-to-the-walls metaprogramming in Java but I think many will think it combines all the worse features of Java and Lisp.
-
Byte Magazine: Lisp
There is this project
https://github.com/paulhoule/ferocity/
which I might finish up when I'm done with the report I'm writing. It is possible to create Java expression trees with trees of static method calls that look a lot like S-expressions and stick them together into statements, methods and classes.
You should be able to do the same tricks people do with LISP macros and it could work code generation miracles but it would have that "LISP curse" problem in spades.
The plan is to generate a code generator that is sufficient to generate the full DSL implementation (ferocity0) and use that to generate the full implementation (ferocity.)
I have some tests for ferocity0 writing .java files to get fed to javac and for ferocity0 running expression trees with a primitive interpreter. Already the type system is enriched over the type system because interpreted ferocity0 can handle Java expressions as a type at run time so you get issues like quoting and unquoting in LISP.
-
What Happened to Lambda-the-Ultimate.org
Internal or external?
I think Java is just fine for internal DSLs, see
https://www.jooq.org/
I was also hacking on this project
https://github.com/paulhoule/ferocity/
which was about making Java homoiconic. Namely in ferocity you can write
Expression literal = of("Hello World");
-
The Number Guessing Game Written in YAML as Lisp Interpreted with Python
You could process that Expression in a few different ways, for instance you could evaluate the tree using reflection or you could turn the tree into source code and compile it with javac.
Going down that path I found it was more about discovery rather than invention. That is, you will discover the issues that come up around quoting in LISP and develop some answers to them. Also for the exercise to be interesting at you will get into an execution model that is a bit bigger than the original language : for the metaprogramming to be fun at all you want to be able to write Expressions that manipulate Expressions so you end up introducing types that don't really exist in the base language. These are almost trivial to handle using the primitive interpreter style but could be more of a challenge to compile to source code.
Some source code is here
https://github.com/paulhoule/ferocity
It's been a long time since I worked on it and I need to see if I have more notes explaining the plan behind it, but the idea was to develop "ferocity0" which was a version of the DSL that was good enough to build stubs for some of the language and a large part of the standard library, and then use code generation techniques to create "ferocity1" which would be like "ferocity0" but would cover 100% of the Java language.
My current side project is being sidelined by supply chain problems so I might go back into that one.
TypeScript
-
React + Ruby on Rails without any gems
How to start using React components written in TypeScript using Ruby on Rails as a server with only built-in Rails features? There are a couple of ways we can achieve it with.
-
Typescrypt: Make your life easier with decorators
Decorators were initially introduced as an experimental feature in TypeScript 1.5 in July 2015, and using them required enabling a specific compiler option called --experimentalDecorators.
-
Create a Responsive Navbar React Tailwind CSS TypeScript
react useState (react.dev) Tailwind CSS (tailwindcss.com) typescriptlang.org
-
React with Tailwind CSS Skeleton Loader Example
typescriptlang.org
-
Building my own ChatGPT
TypeScript: Adding types to JavaScript makes your code more reliable and easier to maintain.
-
Exploring Angular 17 and Beyond: Major Enhancements, Latest Updates, Migration Strategies, and Future Outlook
Angular 17 has sparked a renewed interest among developers with its groundbreaking features and enhancements. Developed and maintained by Google, Angular 17 represents a significant leap forward in front-end technology, setting new standards for Angular Development Services. This latest version of the popular TypeScript-based web application framework is designed to improve developer productivity and enhance user experience. By prioritizing performance, scalability, and maintainability, Angular 17 empowers developers to build dynamic and responsive web applications effortlessly.
-
Svelte Series-1: An awesome framework
Version 3 was a major revision where the Svelte development team began to rethink the core concept of modern UI frameworks: reactivity. By 2019, Svelte has become a mature tool for building out-of-the-box web applications with TypeScript support.
-
React Compiler is now open source
I wish the TypeScript team can actually make a good and fast compiler with type inference support. There are so many opportunities for minimization, optimization, conditional builds, instrumentation, and so on if we can utilize the type info from the TypeScript compiler. Unfortunately the TypeScript team never commit to requests like these, and only commit to idiomatic JavaScript transpilation.[1]
And because TypeScript is so complex and development is so heavy, third party attempts on making a type checker have never succeeded.[2]
I'm curious how far React Compiler can go without the access to TypeScript type info, and if they would invest in compiler tooling for TypeScript in the future. But considering Meta has Flow as their in-house alternative to TypeScript, they might not have the incentive in investing in the TypeScript ecosystem.
[1]: https://github.com/microsoft/TypeScript/issues/8#issuecommen...
-
Branded Types for TypeScript
I made my own proposal: https://github.com/microsoft/TypeScript/issues/202#issuecomm...
-
Cross-platform development using ReactXP
In this post, we want to build a cross-platform mobile and web app. Our technology stack of exploration consists of ReactXP and TypeScript. Source code should be universal for two platforms.
What are some alternatives?
reflect-metadata - Prototype for a Metadata Reflection API for ECMAScript
zod - TypeScript-first schema validation with static type inference
pidove
Flutter - Flutter makes it easy and fast to build beautiful apps for mobile and beyond
Tailwind CSS - A utility-first CSS framework for rapid UI development.
zx - A tool for writing better scripts
esbuild - An extremely fast bundler for the web
gray-matter - Smarter YAML front matter parser, used by metalsmith, Gatsby, Netlify, Assemble, mapbox-gl, phenomic, vuejs vitepress, TinaCMS, Shopify Polaris, Ant Design, Astro, hashicorp, garden, slidev, saber, sourcegraph, and many others. Simple to use, and battle tested. Parses YAML by default but can also parse JSON Front Matter, Coffee Front Matter, TOML Front Matter, and has support for custom parsers. Please follow gray-matter's author: https://github.com/jonschlinkert
Yup - Dead simple Object schema validation
Quasar Framework - Quasar Framework - Build high-performance VueJS user interfaces in record time
rescript-compiler - The compiler for ReScript.
linaria - Zero-runtime CSS in JS library