Dynamic module loading

This issue was originally filed by @dam0vm3nt

This feature was initally described in
Issue #3819:    Provide a Method to Dynamicaly Load Classes
But it has been closed pretending it was done. IT IS NOT as Mr. gbracha honestly admits: "... where the code being loaded is not known statically. This will require the ability advanced capabilities like mirror builders.  This should be a separate issue."
So I'm posting that separate issue hoping sometime in the future will be adressed as it is the only reason stopping me to adopt dart.
In other word: We need some mechanism to dyamically load classes not know at compile time by another module. Something like java class loaders / Flex Module / JS AMD.

any update on this?

+1, I really need this to be able to use Dart for my project instead of ES6/TypeScript.

@hermanbergwerf thanks for the comment. Could you provide specific details on exactly what problem you need solved?

@sethladd I want to build a plugin framework where plugins be executed during runtime so I can move features out of the core into separate modules. Additionally third party developers will be able to develop and run plugins. In JS I could inject the plugin script which could then access a global object from the core that holds an API. I think spawnDomURI from Dart can do the same thing (I think I could pass the API object via args), but there is no dart2js implementation yet. I suppose the compiled JS could also be injected and the plugin could import the core so it can use the API object (which is really just a class with a lot of functions, this should be passed by reference though).

@hermanbergwerf thanks! Just for clarity, do you need this only for your web apps, or are you writing VM-based apps, too?
Also for clarity, it sounds like you need to dynamically load a library into an existing isolate, such that the loaded library has access to all the same memory as the isolate it was loaded into?
(where, isolate == app or web app, in this case)
cc @floitschG

@sethladd Initially only for the web version of my application (http://molview.org, FOSS!) but I'll also run parts on the server for pre-processing. The goal is indeed that a piece of Dart code (not sure if it should be a library) can access the same memory (mainly in order to access the DOM). The injected Dart must be able to communicate with the core. Let's say the core is a single instance of a class where the public methods are the core API. My idea was to pass a reference to this core object so the injected code can interact with the core. Perhaps this is a little to much JS-style. Some kind of messaging would also work. It makes no sense to run the injected code on another thread, so I think that means it should run inside the same isolate. Especially since the injected code should be able to alter the DOM. It would be even better if that could be sandboxed to a specified DOM node (I think the only way would be to use a kind of DOM node proxy, but that's just a wild guess).

Let me echo @hermanbergwerf 's comments, I am looking for exactly the same thing. The idea is that scripts (written in Dart right in the browser in my app) would be able to interact with the core, using the established API. This is pretty much the way plugins (and scripts) are usually implemented in other languages, like C# or Java. The loaded code should operate in the same thread and should have access to all DOM, so isolates are not a solution. Would be awesome to have the same capability in Dart! Plugins can actually be built with the rest of the system, but for scripts dynamic loading (in my case, this will involve dart2js transformation) is necessary.

I will jump on this bandwagon while it's moving as well:
This sort of plug-in mechanism would allow us to break up deployment and iteration on complex apps in Dart by permitting us to update an isolated code module and deploy it without having to rebuild and redeploy the entire application.  This also opens up some nice possibilities for A/B testing of these sorts of things.
Obviously supporting this would have some potentially large impacts on how Dart handles dependency resolution and dart2js bundling of code (deferred loading).

@sethladd Any progress on this issue?

Any progress on this issue?

Nothing right now, we're getting ready to ship 1.12. You might want to reach out to<EMAIL_ADDRESS>mailing list , because the new dev_compiler (aka DDC) might be able to make it easier for you to dynamically load chunks of Dart code into your app.

The dev_compiler does look very interesting!

Well, I think compiler_dev is the answer.  Wonder if we will have to wait
until ES6 becomes fully implemented or if they will make an ES5 driver too.
2015-08-24 20:25 GMT+02:00 Herman Bergwerf<EMAIL_ADDRESS>
The dev_compiler does look very interesting!
—
Reply to this email directly or view it on GitHub
https://github.com/dart-lang/sdk/issues/10530#issuecomment-134327271.

You can use ES6 tools to transpile dev_compiler generated ES6 to ES5. I think Babel is such a tool there are probably more but I do not concern myself with this topic and my knowledge is sparse.

Yeah I know that. At the moment this is an option but IMHO more for
"peeking" what is going on. There are many ES6 -> ES5 compilers, but this
kind of solution is going to be very hard to debug and also a comple
workflow for building.
For real use, unless there's a direct ES5 driver, I think that one should
wait until ES6 become ready on major browsers.
2015-09-13 16:01 GMT+02:00 Günter Zöchbauer<EMAIL_ADDRESS>
You can use ES6 tools to transpile dev_compiler generated ES6 to ES5. I
think Babel is such a tool there are probably more but I do not concern
myself with this topic and my knowledge is sparse.
—
Reply to this email directly or view it on GitHub
https://github.com/dart-lang/sdk/issues/10530#issuecomment-139879198.

Hey guys,
Any news on this?
A new project just came in, a custom CMS which requires the server-side execution of user-defined functions on specific events (beforeRecordSave, aftertRecordSave, beforeRecordDelete, beforeStateTransition, custom record actions, etc). Security is currently not a problem.
I'm growing fond of my Dart CMS and would love to extend it to fit the bill. But the lack of dynamic loading is currently a no-go.
I'd love having feedback soon.
We could afford to wait up to 6 months for this feature, while we work on other requirements.
But if it's not coming, we'll have to start in Java or C# right now.
Thank you :)

Take a look at the DCC (new developer compiler) : it will handle different styles of module loading.
But at the moment it is still not ready for the web.

I need dynamic loading in the VM. I'd like to use Dart server-side, not for the browser (at least currently).
Hot-reloading is currently being implemented, it may be related.
And Observatory already supports dynamic statement evaluation (not sure to what extent).
So maybe it wouldn't be that much work.
What I'd like is to evaluate a string at runtime and have it compiled to a function or class, in the VM.
Or maybe load a dynamic library (similar to .dll, .so) and get a list of all top-level declarations.

I am willing to use Dart ServerSide on most of my projects and projects of companies that I can choose or suggest to.
However, Dart needs to evolve faster =\

Ddc can produce modules and code for node if you want to run it serverside.
But you are right. Actually the dyn mod is a feature of the build system and not the language.

I can't stand anything related to JS and the last time I tried node, it was too much of a mess for my taste.
In the VM, we could run dynamic code in an isolate, with some glue for communication.
But we need to include dynamic DB access inside the caller's transaction.
We could provide DB services to the dynamic code which goes back to the original isolate.
But it all seems overly complex, brittle and inefficient.
Sadly, given there's little interest on this feature, we choose another language stack for the project.

Js would be only the finalmente result you would see only Dart... But understand what you are saying. Sometimes I feel frustrated too

I'm just philosophizing here (I've had a glass or two) ...
Maybe we could avoid the "wild west" of dynamic loading by implementing something similar to deferred loading.
import 'package:dynamic/loading.dart' deferred as myLib;
await myLib.loadLibrary();
myLib.doSomething();
Maybe something like the following would possible, without turning the world upside-down (I guess it would :) ...
// Only defines the API a dynamic library must adhere to.
import 'package:dynamic/loading.dart' deferred as myLib;
// Specifies the path to the (dynamically generated) library file.
LibraryMirror myLoadedLib = await myLib.LoadLibrary('lib/myDynamicLib.dart');
// We need a way to cache the result (and maybe unload it).
// Use the dynamically-loaded library using the mirror myLoadedLib ...
// ... but it would be a lot more user-friendly to treat it just as an import prefix (or an instance ...).
myLoadedLib.doSomething();
Since Dart is transitioning from scripting to an AoT-friendly language (Dart 2.0?), I think it's important to reconsider the import/export scheme and how dependencies are looked-up. (I like how Rust handles imports and lookups).
Conceptually, I don't see much of a difference between a library (or package in Java/AS3/etc) and a singleton. Libraries only differ to singletons in minor ways, mostly due to language/runtime restrictions.
// An hypothetical language ...
package lib1 {
class Lib2Class {
void doIt() { ... }
}
final MyClass lib2 = const Lib2Class();
package lib3 {
void doIt() { ... }
}
class lib4 {
static void doIt() { ... }
}
}
I don't see much of a difference between "lib1.lib2.doIt()", "lib1.lib3.doIt() and lib1.lib4.doIt()" (except for namespaces, "this" within methods, which could resolve to the current library if static, and the AoT/runtime lookups). Basically, libraries are self-defining AoT-friendly singletons.
I think of a dynamically-loaded library as an instance of a class which implements the static API of a library (or package).
We already have the concept of static APIs with deferred loading and configurable imports. We could just "allow" instance implementations of those static APIs ... and dynamically load them ...
Of course there are corner-cases ...
I believe a dynamically loaded library/instance should have access to all/some packages from the importer.
We should be able to define a path where to lookup for missing dependencies.
... a lot more I'm not aware of ...
Thoughts?

I'd like to push for this, specifically on the VM. The test package is getting closer to the point where it needs to load user-defined plugins, and pub's isolate-based plugin loading has convinced me that that approach ultimately isn't usable. Needing to manually serialize and deserialize all APIs to let them pass through the Isolate API is a huge productivity tax and sometimes a performance tax as well.
I'm hoping the recent work on hot reloading makes intra-isolate dynamic loading more feasible. Here's an example of the sort of API I'd like to see:
/// Loads the Dart file at [url] in the current isolate, invokes the top-level
/// function named [functionName] with [argument], and returns the result.
Object loadDartFile(Uri url, Symbol functionName, [Object argument]);

This would use the current isolate's package resolution. If it's invoked from a snapshot, it would use the snapshot's location to find a .packages file, but it would load snapshotted libraries if possible.

I think the best way to go with this is raising the  dartdevc from "dev tool" status to fully "production oriented status". dartdevc infact already supports dynamic loading modules as it leverages js modules (AMD, ES6, ecc.) and summaries for symbol resolutions. So I hope they will follow that path.
To better understand what I'm saying you can take a look at this and this.

@dam0vm3nt this would be very useful for other purposes than web development.

@bergwerf I agree 100%. For example @nex3 showed another use case.
I'm trying to push for this with the dart team. If you believe that this could be an important feature you can do the same in the gitter channels or the forums.

I'm so rooting for this in the VM, even if not implemented for other targets.
@nex3, in your example, it seems it would be required to reload the URI if we plan to execute the method a second time.
I think it would make sense to load the URI first into an object, then call whatever methods whenever we need to.
var object = loadDartFile(myUri); var result = object.invoke(myMethodSymbol, myMethodArgument);
We could try to make the module adhere to a custom interface:
T loadDartFile<T>(Uri url);
Then:
abstract class MyExternalService {   void connect(String argument); } var service = loadDartFile<MyExternalService>(myUri); service.connect("meh");
Loading from bytes would a really nice extra:
Object loadDartBytes(List<int> bytes);

@fmorgado You can always have the method that's called return a function that can be called multiple times. Another option would be to allow the symbol to refer to any top-level name, so it would return a function object that you'd have to manually call.

@nex3
True. I didn't see it that way.
We'd call the "module main" which would return whatever methods/interfaces we'd need.
Seems cleaner.
I insist that loading dart code from bytes would be very useful. May not mean much for CLI tooling but it would on the server, where filesystems are increasingly obsolete.

Hoping there are some functions allowing loading compiled dart classes, just like "loading DLL on Windows" or "loading *.dex on Android".
BTW, is is possible to let the program load dynamic module plugins for now?

This would also be very useful for Dart Sass, which allows users to define custom functions and importers but doesn't currently have any way of loading them from the command-line.

Note: this recently became higher-priority for Dart Sass, because Google users want to be able to easily load an importer that supports a Bazel-style virtual filesystem overlay without rewriting the wrapper executable.

I don't see dynamic code loading into an isolate happening any time soon.
Our current compilation model does not lend itself to non-isolated code loading.
Loading the code in an isolated way prevents type-compatability, and then you might as well use isolates on the VM anyway.

So has this thing progressed?

No, they (dart team) has killed it (see the https://github.com/dart-lang/sdk/issues/10530#issuecomment-416782367) .

@dam0vm3nt  Is there a better solution to the above problem?

@DartBot Did you give up on dart？😢

@dam0vm3nt Is there a better solution to the above problem?

I've created a dart2ts compiler (https://github.com/polymer-dart/dart2ts) that can be used to produce a more "modular" code. It's usable even if it needs more testing, but you can give it a try.

@miaosun009 what is your use case?

@mraleph Like most people, I look forward to this feature and am evaluating whether dart can be deployed in real projects

@mraleph If it's technically possible, why not? Dart users expect this feature

@miaosun009 well, that's why I asked about the concrete use case you are evaluating Dart for.
For example, you might be using Dart on VM in JIT mode on the server. That's one situation - in this situation dynamic code loading is rather simple to implement and it would not have any negative impact on the performance of the code you are running.
But you might be also using Dart on VM in AOT mode (e.g. as part of Flutter) - in this case dynamic code loading is a much harder problem, as AOT currently assumes closed world knowledge about your program - and permitting your code to load other arbitrary code dynamically violates this assumption. This would have profound implications on performance and code size of your code. (performance would be worse and code size would go up considerably - because tree shaking becomes much harder).

@mraleph Thank you for your reply. My use cases are more about the server side, Dart vm, so will such features be implemented on vm in the future?

@miaosun009 on the server side you can try using IsolateMirror.loadUri and see if it satisfies your needs.

@mraleph  Thank you. seem to have found what I want

AOT dynamic class loading is required to develop a plugin system for desktop applications. This is now relevant due to flutter supporting desktop.
Currently it seems it would be impossible to implement dynamic plugins a la vs code or intellij.

I'm looking for this feature for a very long time, and it's disappointing that it's in a discussion knowing the importance of it for the community. I just don't get why the team does not think it's an important feature.

I just don't get why the team does not think it's an important feature.

We understand very well that this feature might be important for some very specific niche use cases. However as explained in this comment dynamic class loading and AOT don't play well together.
So for the foreseeable future you have a choice of

Deploying your applications in JIT, which support dynamic loading;
Deploy your applications in AOT and isolating your dynamically loaded code inside a separate isolate or in a separate process (which is what VS Code does to their extensions).

@BugDiver what is the use case you are looking at? Is it plugins or something else? Is it for Flutter or something else?

Is it plugins or something else? Is it for Flutter or something else?

It sort of plugin. the workflow is following (gist)

The plugin is lanched by a Framework
The framework and plugin communicate using RPC
The plugin needs to load some Dart code (User code) when it's launched and perform reflection to get metadata of user code

You can think of as a test runner which needs to load the dart files (test files) and then reflect to collect the metadata

@BugDiver from your description it does not sound like you actually need the same type of dynamic code loading as requested in this issue. Given that plugin and framework are already separated by RPC they are not required to exist within the same isolate or process. Furthermore, to extract metadata from Dart code you don't really need to load it, it is enough to parse it (using package analyzer or package front_end). Additionally it seems that you are targeting JIT mode specifically - so IsolateMirror.loadUri could work for you (though I would not recommend using it). Hard to say more given that I am missing a lot of details - but that's my assessment based on the information provided.

it does not sound like you actually need the same type of dynamic code loading as requested in this issue
Maybe.

to extract metadata from Dart code you don't really need to load it, it is enough to parse it

Well, that won't be sufficient because I also need to get the methods and class instances. So static parsing is not what I need.

Given that plugin and framework are already separated by RPC they are not required to exist within the same isolate or process

Yes, the plugin and the framework are isolated from each other, but the plugin needs to load the User's code.

so IsolateMirror.loadUri could work for you (though I would not recommend using it)

That might work, but as you said it's not recommended.
For more details,
Things of it as a test runner which can be used for any language, given that there is a plugin written in that language. The test runner launches the plugin and later requests it to execute certain tests. The plugin's job is to load the user's code, perform reflection, collect classes, create instances, and get methods inside that.

Well, that won't be sufficient because I also need to get the methods and class instances. So static parsing is not what I need.

Ok, makes sense. I think you have three possible implementation strategies (sorted from least future proof to most future proof):

Use IsolateMirror.loadUri to load dart code into the current isolate. Use dart:mirrors in the current isolate to reflect on it.

Use Isolate.spawnUri to spawn dart code in a separate isolate and dart:mirrors to inspect it. You would need to create an auxiliary entry point file (you can pass it as data-uri to spawnUri), like so
// entrypoint.dart
import 'actual.dart';
import 'dart:mirrors';
void main() {
  // Use mirrors here to reflect on actual.dart
}

Combine parsing with code generation to avoid the need for dart:mirrors. Imagine for example that you have something like
 // test.dart

 class Smth {
   @test
   void foo() {
   }
}

You parse test.dart and figure out that you need to run foo on Smth because it is annotated with @test. Then you can generate something like this (I am simplifying - you can tweak code generation to suite your goals):
// entrypoint.g.dart
import 'test.dart';

void main() {
  test("Smth.foo", () => Smth().foo());
}

Now you can load entrypoint.g.dart into a separate isolate and it will run the test. No runtime reflection necessary.

You can also use https://pub.dev/packages/reflectable to take care of code generation for you - this allows you to replace dart:mirrors without figuring out how to do parsing.

@mraleph Thanks for all the pointers.
Few questions

Use IsolateMirror.loadUri to load dart code into the current isolate.

Isn't IsolateMirror an abstract class? How can I create a concrete IsoalteMirror? (this might sound dumb, but If I extend I have to implement the loadURi)
Or are you pointing me to use currentMirrorSystem().isolate?

Second option is something which also came to my mind, but last time when I tried that, it was consuming quite a lot of time (proportional to the number of files I import in the auxiliary file). Will give it one more try

the Third option seems a bit trickier and error-prone to me (Not sure I might be wrong)

@BugDiver Yeah you need to use currentMirrorSystem().isolate.
For second option if you want to minimize time you can load them all into the same entry point, instead of generating multiple entrypoints per test file.
I think for the third option it is best to use something like reflectable to take care of parsing for you.
Anyway - I suggest we move this discussion to somewhere else to avoid spamming this issue further - feel free to reach me at<EMAIL_ADDRESS>

@mraleph Thank you so much for the help.

@mraleph
But you might be also using Dart on VM in AOT mode (e.g. as part of Flutter) - in this case dynamic code loading is a much harder

As far as I can tell, this issue still lives within Flutter, even in JIT mode (debug mode), mirrors isn't an option to load code there.
My use case is loading Widget class dynamically to a running Flutter app.
My proposed solution to this issue is compiling the code to dill without an entry point, which then can be loaded to the same isolate
but then again this would only work inside a JIT runtime...

As far as I can tell, this issue still lives within Flutter, even in JIT mode (debug mode), mirrors isn't an option to load code there.

Yes, mirrors are completely disabled in Flutter to avoid situations where people write code that works in debug builds (which use JIT), but breaks in release builds (which use AOT).

@mraleph
In flutter, I have following problem which I think is impossible to solve without dynamic module loading.
let's say for example I have 1000 user in the app, there is a page called "my_widgets", each of these users have 10 widget on this page, (not flutter widget, just some complicated functionalities) so it will be 10 000 completely different "widgets" for all of the users, if we integrate all of the 10 000 in one app, app size will be gigabytes, So we need to have them somewhere on the server, so each user will download only those "widgets" which they need, so we will maintain the app size smaller for downloading from playstore. if you can think of any way around will be great but I think it's not really possible without reflections and basically dynamic module loading.
I often hear in github issues that dart and flutter staff really don't care about reflection and dynamic module loading(I read Hixie's comment about reflections that they were not needed at all)  when I believe and I think no one will argue that, they are things which modern and powerful language should have, or otherwise it will be some fake language trying to be like java or C#.

I did not know that.
Really?
Dart doesn't support reflection or dynamic module loading?
Any serious language currently has these possibilities.
I thought Dart would be a modern language for creating modern applications.
A language in windows must be able to create dynamic modules, for example, a large application may have a manufacturing module, another accounting module, another billing module, another stock management module, ....
Today's applications require modularity.
If this is not possible with Dart I am seriously disappointed.
I was thinking of adopting language as my preferred language, but if it does not have these possibilities, I will have to think about other languages.
Regards,
Jose

It would be possible if bytecode is still available: Remove bytecode generator

But bytecode is not necessary, for example the Delphi (Object Pascal) language is fully compiled and allows dynamically loading modules that can be used from within the main application as if everything were a single application.
Modularization of applications is extremely important in large application environments that must load and unload memory modules depending on what the user is doing at the time.

@Josua2012  It supports reflection. I will be precise and say that, It does not support "static reflection" which means just to build the class by givin string as a classname to reflector. You need to have Type already defined, and visivle for reflector so it can create class from it. After that, you can do traditional reflection ops: adding methods and properties dynamically.
Other thing is that when you use reflection  dart and its tree shaking freaks out and imports everything from every file, which makes executable huge in size. For that you are using reflectable package to anotate classes which you are going to reflect with @reflectable. So now it knows which class is going to be reflected  so tree shaking kinda gets into shape, but I really don't think it is perfect solution.
Problem I was talking about, was about flutter, which does not support reflection in production cause it uses AOT compilation. And also it does not support dynamic module loading.
Note:
Last version of flutter, specifically 2.13 was talking about deffered libraries which is supported only on android, which basically does the following, connects to playstore api and downloads needed library while you are opening your app first time. This way download time is less. To put it simply, you can have your libraries somwhere else and it will be downloaded and merged after using opens app first time, main executable or downloadable file only knows about urls that for those libs.

@Josua2012 Yes they are good, language/framework for small and for enterprise if you don't need reflection. :)

@campfire5
I see the problem for large desktop applications on windows.
Could you tell me where I can see an example that shows how a main application shows windows (Stateless and Stateful widgets) dynamically from other modules dynamically loaded in memory?
The idea is to have the main application and have dynamically loaded modules that can be the warehouse management module, the accounting module, the human resources management module, ...
Thank you very much for the help.

I don't really lnow examples for stateless or statefull widgets, but you can try reading Gilad Bracha's book dart programming language, one of the last chapters there are dedicated for the reflection.
Note:
Some of yhe contents of the book is outdated but don't be discouraged because of that. I think it will be useful.

@mraleph
In flutter, I have following problem which I think is impossible to solve without dynamic module loading.
let's say for example I have 1000 user in the app, there is a page called "my_widgets", each of these users have 10 widget on this page, (not flutter widget, just some complicated functionalities which contain flutter widgets to basically have visual) so it will be 10 000 completely different "widgets" for all of the users, if we integrate all of the 10 000 in one app, app size will be gigabytes, So we need to have them somewhere on the server, so each user will download only those "widgets" which they need, so we will maintain the app size smaller for downloading from playstore. if you can think of any way around will be great but I think it's not really possible without reflections and basically without dynamic module loading.
I often hear in github issues that dart and flutter staff really don't care about reflection and dynamic module loading(I read Hixie's comment about reflections that they were not needed at all)  when I believe and I think no one will argue that, they are things which modern and powerful language should have, or otherwise it will be just another language failing to be as powerful as java or C#.

I am quoting my comment, where I described problem for thousands of widgets, the best solution was with dynamic module loading, but as long as it was not possible my way around was the following:
Create a large map with all the widgets, you may need to load dynamically, but instead of literraly assigning widgets to Map's values use closures instead. So as long as closure is literal representation of the code, it does not instantiate the classes inside it until it is called.
E.g sudo code:
Map<String, Function> wMap = {
"first_widget":(BuildContext context) {
        return Container(....)
    }
......
......
}

// And usage will be
.....

...child: wMap["first_widget"](context);
.....

@campfire5
If I have not misunderstood, with the system that you propose to me, all the application code would still have to be in the main application, although the objects are only going to be created at the time of use.
If what I have understood is correct, I believe that this is not the solution, since what is sought is that the main application is not very bulky.

@Josua2012 Yes you understood correctly, I mean main idea of that is that memory will not be exhausted while rapp is running.

I think @mraleph Thoughts would be great to hear about it.

If the objects are handled correctly, you should not have a memory problem.
What amazes me is that the Dart team did not include a good system for dynamically loading modules.
All languages today contemplate this possibility, since it is fundamental for modern applications. 👎

Yes, it would be very interesting to know the thoughts of @mraleph :)

If the objects are handled correctly, you should not have a memory problem.
What amazes me is that the Dart team did not include a good system for dynamically loading modules.
All languages today contemplate this possibility, since it is fundamental for modern applications. 👎

They say AOT compilation principles, excludes possibility of reflection, but I don't really have deep understanding of those principles.

If the objects are handled correctly, you should not have a memory problem.
What amazes me is that the Dart team did not include a good system for dynamically loading modules.
All languages today contemplate this possibility, since it is fundamental for modern applications. 👎

If you are using thousands of comples custom widgets there is a big chance you will came across problems, at least in and android app case you will have battarey consumption very high and it is a big problem.

@campfire5
Let's specify ideas, a Windows DLL does not have, nor does it need reflection, however it can be loaded from an application.
A Dart module could expose classes as an interface, so the main Dart application, without the need for reflection, could use those classes.
If the Dart development team doesn't want to do this, it's not because they can't.
Neither all the objects nor all the windows of an application are used simultaneously, if someone does that, they have poorly developed their application.
A well-designed application does not have to cause memory problems in any case. :)

I think you should be able to use reflection and reflectable on windows fluently its a problem of flutter mostly, although you will not have ability of static reflection, So let's define a problem, if you are using reflaction dart executable needs to be aware of all of its body all of it's code to introspect it and create reflections of an object, So executables size gets bigger because during compilation dart needs to compile everything for the sake of reflection. With reflectable you are just telling it which class should be compiled fully and not only its parts, it means wherever you have imported file which includes reflectable class, that class will be compiled fully which undermines the tree shaking principle only for that class or classes.  So basically, tree shaking is a  kinda oposite of reflection in dart, and because of that you don't have modules as interfaces, but if you undermine it and use reflaction basically you will have modules or classes as interfaces but it will be loaded in memory and your executable will be pretty large. Reflactable package just makes it more specific and light weight.
Those are main things in compilation and I think this is the problem but again we need to hear from @mraleph to know it much better. So maybe there are other reasons as you say it.

Let's hope they say something from the dart development team. :)
Thanks.

I really need a framework-plugin system just like a C++ executable dynamically loading DLLs.
BUT: How can such kind of functionality be secure in Flutter? As soon as my Flutter app loads an infected module, this module has power over the whole device. Things will go bad.
We need a plugin concept working with permissions. A module should not use the camera or even render a widget (e.g. fake login system) unless the app/the user has authorized it to do so. In fact, this must be pretty hard to implement securely. But what about an interpreted approach: The Flutter app can read and parse a script with little functionality. Any special or performance critical function can then be exported from the script engine to the script.

Actually, any programming language can have the same problem, the applications that are developed can access most of the functionalities of a computer.
But that is not the important thing, the important thing is that Dart has the possibility of modularizing an application and allows those modules to be dynamically loaded. :)

This security concern could be solved by signing these dynamic libraries with a certificate. So that only trusted code could be loaded in your app.

@Josua2012 It supports reflection. I will be precise and say that, It does not support "static reflection" which means just to build the class by givin string as a classname to reflector. You need to have Type already defined, and visivle for reflector so it can create class from it. After that, you can do traditional reflection ops: adding methods and properties dynamically.
Other thing is that when you use reflection dart and its tree shaking freaks out and imports everything from every file, which makes executable huge in size. For that you are using reflectable package to anotate classes which you are going to reflect with @reflectable. So now it knows which class is going to be reflected so tree shaking kinda gets into shape, but I really don't think it is perfect solution.
Problem I was talking about, was about flutter, which does not support reflection in production cause it uses AOT compilation. And also it does not support dynamic module loading.
Note: Last version of flutter, specifically 2.13 was talking about deffered libraries which is supported only on android, which basically does the following, connects to playstore api and downloads needed library while you are opening your app first time. This way download time is less. To put it simply, you can have your libraries somwhere else and it will be downloaded and merged after using opens app first time, main executable or downloadable file only knows about urls that for those libs.
@campfire5 I need to create a deferred component out of a custom package as it contains huge assets and the aab exceeds the 150MB Play Store limit. The deferred libraries you were talking about would be exactly what I need, can you tell me a bit more about them?

This comment was originally written by @dam0vm3nt

I think this is, not only desiderable, but also of extreme importance for
Dart success.
Dart needs a way to create extensible and modular application. Isolates can
actually be used but they are a very poor mechanism when it comes to
intra-module communication.
Let's make an example. I have a project that consist in a new fantastic
social network that's written in DART. I want thirdy party to contribute
with they're fantastic App. But I want them to seamlessly integrate to the
main framework.
If I were using in any other programming language (Flex, Java or even JS)
all I have to do is to provide the contract API, i.e. a set of classes to
extend and interfaces to implement so that a thirdy party  can implement
their App.
Then the thirdy party could upload their module (preferably in a "compiled"
form) and their app could be installed and executed - just because it is
conformant to the contract API. The framework in turns could simply load
the compiled code and run it (for examble in Java we have Classloaders, in
Flex URLLoader, in JS a plethora of api).
If I'm not missing something at the moment if we want to implement this
simple and common pattern (i.e. a framework - plugin pattern) with dart we
have only two choices:

use the power of OO approach and provide a contract API in terms of
classes and interfaces and not using isolates. In this case we need to
RECOMPILE ALL THE framework every time we have to integrate a new plugin.
This also means that we cannot provide an authonomous and automatic way for
a thirdy party to add their plugin but there must be a human procedure.
Unfeasible.

specify the contract using some sort of "communication protocol" and
using Isolates. We cannot provide classes to extend because there's no way
an isolate could return an object to the framework implementing some sort
of contract. Isolates can communicate only "simple data" and using "copy by
value". This is a very poor approach, complicated, error prone. But the
main defect IMHO is that we are restricted to use "copy by value" approach
making difficult to pass big data structures and to share implementation
across different peer plugins or between the framework and the plugin.

I hope I'm wrong and someone could teach me a third way because so far this
is the only reason for people like me and my company for not to adopt DART
now and until this is fixed. Don't think we are the only one expecting this.
Security should not be an excuse for not implementing important features
like this. Otherwise the most secure language is the less powerfull.

Exactly.
Any news on this? Dart and Flutter really needs plugins/modules system.

I would also be interested to hear if the devs have plans to implement this

A lot of time has passed and everything is still the same, apparently nobody is interested in this functionality. :(

I need this functionality.

Yeah, currently most of the software we use everyday has a system that allows you to add additional third party functionality.
Browsers, IDE's, notetaking apps, some mail clients and a lot of other stuff has some kind of extensions or plugin system.
If we want to make app's that can match modern day user expectations about costumisability we really need a way to load code on the runtime.

I am waiting for this functionality for a long time.

If we can just hold in there until May of next year, we will have gone a whole decade hoping for this.  That's sorta an achievement in itself.

Has any work been started on this? I'm happy to see if I can contribute to the core to get modular deployables implemented.
I'm working on a Flutter SPA that integrates with clients' existing backend ERP, CMS, and/or databases. In addition to those externals being different per client, clients also want UI customization that requires source-level changes Not all clients will be subscribing to all features.
Normally I would modularize all the components and have a list of modules that load per client.  Without modularization I either have to maintain one monolithic product per client, or one one single monolithic product that includes everything for every client and runtime logic to call the correct functionality.
Imagine there was no way to dynamically load images and every user you have wants their avatar photo displayed in an App/SPA. You'd have to either build your package with every photo in the assets folder and rebuild and redeploy every time a photo is added or changed, or build unique deployables for each client with their customized avatar.png.
C/C++ has a simple interface for dynamically loading compiled code. Compiling a modular object includes a symbol table that can be used with dlopen/dlmopen and dlsym/dlmsym to interact with components. Given that Dart allows function pointers to be passed as arguments and be stored in Lists/Maps, could a base "DynamicModule" object load a compiled Dart module file and store all the symbol names and pointers in a Map for access? (This could also allow for hot-swapping running code without restart which is useful for services.)

What you say feel a little bit complicated to me, but the flutter app example is good. I see that loading additional app modules / parts would really help.
Another example are community made ones. You create an app, and you have community around it. Now the people in this community that are develepers could create their own modules / extensions to add new functionality to your app.
This is a must have for many modern day apps. For example vscode. Without the dart extension development would be way harder.

I also need it. With this functionality, I would definitely use Flutter in my project. Without it, I have to seek other solutions.

The team currently does not have any plans to provide support for modular AOT deployments (at least in short term).
If you need this sort of functionality you either need to run in JIT (which supports dynamic code loading) or run your modules in separate isolates - which is supported in AOT - you can use Isolate.spawnUri to load an AOT compiled module as an new isolate.

If we can just hold in there until May of next year, we will have gone a whole decade hoping for this.  That's sorta an achievement in itself.

It isn't may yet, but github shows that it's 10 years already. Someone should make a meme with that skeleton sitting on a chair underwater.
"Me waiting for flutter and dart to get dynamic code loading."

The team currently does not have any plans to provide support for modular AOT deployments (at least in short term).
If you need this sort of functionality you either need to run in JIT (which supports dynamic code loading) or run your modules in separate isolates - which is supported in AOT - you can use Isolate.spawnUri to load an AOT compiled module as an new isolate.

That's sad, Isolates won't work for this. They may be good for doing background work, but not for adding new features to an app (and rendering widgets).

That's sad, Isolates won't work for this. They may be good for doing background work, but not for adding new features to an app (and rendering widgets).

If you want to allow new features to bring in arbitrary widgets then things get complicated, yes. But if you limit your features to a fixed set of widgets they can use (those built into the main app), then I think it is possible to use isolates: you just need to develop an API for building widget trees out of supported widgets and sending them to the main isolate to render. It's a bit of boilerplate work (you would have to duplicate API surface of all widget classes you need to use), but it is hardly infeasible. Alternatively you could build on top of something like https://pub.dev/packages/rfw instead.

Found this project that may be a adequate (albeit very heavy) substitute but it's still WIP:  https://pub.dev/packages/dart_eval
_dart_eval is an extensible bytecode compiler and interpreter for the Dart language, written in Dart, enabling dynamic codepush for Flutter and Dart AOT.
The primary aspect of dart_eval's goal is to be interoperable with real Dart code. Classes created in 'real Dart' can be used inside the interpreter with a wrapper, and classes created in the interpreter can be used outside it by creating an interface and bridge class.
dart_eval's compiler is powered under the hood by the Dart analyzer, so it achieves 100% correct and up-to-date parsing (although compilation and evaluation aren't quite there yet.)
Currently dart_eval implements a decent amount of the Dart spec, but there are still missing features like generators, Sets and extension methods. In addition, much of the standard library hasn't been implemented._


All templates should have custom resolver example

All templates should have custom resolver example in order to show how graphback can be used with custom logic

Fixed by https://github.com/aerogear/graphback/pull/1956


Traffic Ops postinstall should detect that an installation (configuration) already exists

@daniel_kirkwood

...and not ask to setup a new CDN. Should even work for dev environments? Maybe i'm barking up the wrong tree with this.

lots of work done on postinstall in the past few releases.  I just tried this with 1.5.0-RC3 -- it still runs carton for Perl deps and checks web deps, but runs quickly if no change.  I'm declaring this done...


fix: partial fixes never applying

Fix fixes in files which still have remaining issues not applying due to the change in behaviour of npm-groovy-lint status code handling in 11.0.0 by now requesting failon: none.
Readiness Checklist
Author/Contributor

[x] Add entry to the CHANGELOG.md listing the change and linking to the corresponding issue (if appropriate)
[x] If documentation is needed for this change, has that been included in this pull request

Reviewing Maintainer

[ ] Label as breaking if this is a large fundamental change
[ ] Label as either automation, bug, documentation, enhancement, infrastructure, or performance

Superseded by #185


During the inference, input the same data, the output will be different

I used your code to train on another dataset. When training, it can get very good (eval) results.
However, during the inference, I even could not synthesize a sound that could be heard. Input the same data, the output will be different (each time the sequence length has changed, and different from the input sequence length).
I print "embedding input", "encoder output" and "decoder output" tensor to see what's wrong(in the following picture).

I found the problem occurred in the decoder. The same data passed through the decoder, the length and the value has changed. However,  I can't take out the tensor inside of the decoder by any means. The following error will be reported.(I have tried many methods)
ValueError: Operation 'Tacotron_model/inference/decoder/while/CustomDecoderStep/decoder_prenet/dropout_2decoder_prenet/dropout/mul' has been marked as not fetchable.
Do you have any idea about my problems?
Meanwhile, Would you share me your debugging tools? It is so hard to debug in the decoder. This problem has been bothering me for a week. Looking forward to your reply! Thank you very much!

Hi,
this is due to dropout being applied at inference time. Dropout introduces randomness in the generation of the mel spectrograms.

@alexdemartos
Thank you! It is indeed this problem.
But after I fixed the dropout, the generated audio is still very bad. However, I think I have found the problem. It's very likely that my model is not well trained, but ground truth is used during the training phase, so it works well during the training phase, but it works poorly during the synthesis phase. Just like #206 . I think this model may not work for my dataset and input so far.

The problem with this model is that the decoder RNN learns very well how to produce audio based on previous (ground-truth) outputs, but the alignment model is extremely weak. So basically your decoder doesn't care what the inputs are, it just learns that "after B goes C".

That's right. The good results in the evaluation once made me think that the model training is very good. However, I found that the alignment is very bad. I don't understand why I can't train a good alignment.


tokio-threadpool reads stale stack frames in status_service

Bug Report
Address sanitizer reports invalid reads inside tokio-threadpool during status_service test cases. The code in question is pretty complex, and on a drop path, so I haven't been able to verify that it is definitely wrong, but there are unsafe thread locals involved, so it seems plausibly wrong.
tokio-threadpool is deprecated so it seems the best solution is just to replace it completely, presumably with yatp cc @sticnarf
What version of TiKV are you using?
e5afd630e35b42e970e6184e8b71eb98263a9363
What operating system and CPU are you using?
Linux
Steps to reproduce
ASAN_OPTIONS=allow_addr2line=true RUSTFLAGS="-Zsanitizer=address" cargo -Zbuild-std test --target=x86_64-unknown-linux-gnu --lib -p tikv -- security_status_service_without_cn

What did you expect?
What did happened?
https://gist.github.com/brson/049fbb51e7cf6a7e373a652e4bffbaf2

The status server uses hyper. We cannot replace it with yatp because hyper requires a tokio runtime.
I'm not sure if upgrading it to hyper 0.13 with tokio 0.2 solves this problem.

afaik hyper does not require tokio, but it does use tokio by default.


Feature fix definition of the inner product distance

This PR is related to this thread https://github.com/unum-cloud/usearch/issues/405
It proposed a simple fix for Inner Product distance definition
P = - sum(a[i] * b[i])

another place which is probably causing confusion
#if SIMSIMD_TARGET_NEON
        if (viable & simsimd_cap_neon_k)
            switch (kind) {
            case simsimd_metric_dot_k: *m = (m_t)&simsimd_cos_i8_neon, *c = simsimd_cap_neon_k; return;
            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_neon, *c = simsimd_cap_neon_k; return;
            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_neon, *c = simsimd_cap_neon_k; return;
            default: break;
            }
#endif
#if SIMSIMD_TARGET_ICE
        if (viable & simsimd_cap_ice_k)
            switch (kind) {
            case simsimd_metric_dot_k: *m = (m_t)&simsimd_cos_i8_ice, *c = simsimd_cap_ice_k; return;
            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_ice, *c = simsimd_cap_ice_k; return;
            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_ice, *c = simsimd_cap_ice_k; return;
            default: break;
            }
#endif
#if SIMSIMD_TARGET_HASWELL
        if (viable & simsimd_cap_haswell_k)
            switch (kind) {
            case simsimd_metric_dot_k: *m = (m_t)&simsimd_cos_i8_haswell, *c = simsimd_cap_haswell_k; return;
            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_haswell, *c = simsimd_cap_haswell_k; return;
            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_haswell, *c = simsimd_cap_haswell_k; return;
            default: break;
            }
#endif

        if (viable & simsimd_cap_serial_k)
            switch (kind) {
            case simsimd_metric_dot_k: *m = (m_t)&simsimd_cos_i8_serial, *c = simsimd_cap_serial_k; return;
            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_serial, *c = simsimd_cap_serial_k; return;
            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_serial, *c = simsimd_cap_serial_k; return;
            default: break;
            }

        break;

cos is used for dot  ?

Yes, that was historically the case, but that should probably
be changed. I was planning to look into it next week. It may require new kernels, but those should be easy to design by stripping the cosine implementations.

dot - is not a strict distance metric in math terms, hence probably the confusion in various places in the code

@ashvardanian  do you know how it is possible ? I still don't undestand how the kernels are being picked, but it looks like simsimd should be used here, so my changes should not affect the search.

SimSIMD should be used in most Linux builds. But you are right to note, that there is a lot of stuff on the main-dev that hasn't been merged yet 🤗

hi, this probably can be closed, right ?

It will be automatically closed, as we merge the branch 🤗

ok, thanks !

Hi @ashvardanian  I assume I can close this PR, correct ?


switch back to versioned minetest image

fixes #13

Pull Request Test Coverage Report for Build<PHONE_NUMBER>2
Details

0 of 0   changed or added relevant lines in 0 files are covered.
No unchanged relevant lines lost coverage.
Overall coverage remained the same at 69.258%

Totals

Change from base Build<PHONE_NUMBER>6:
0.0%

Covered Lines:
196

Relevant Lines:
283

💛  - Coveralls


New errors associated with the use of --parallel since updating Xcode

Since updating to Xcode 14.3 — I think that's right, but I'm not sure — I've been seeing a flood of errors whenever I use --parallel. Here's a sampling of the error messages:
...
<unknown>: error: Unable to read configuration: The operation couldn\U2019t be completed. (NSCocoaErrorDomain error 256.)
<unknown>: error: Unable to read configuration: The operation couldn\U2019t be completed. (NSCocoaErrorDomain error 256.)
<unknown>: error: Unable to read configuration: The operation couldn\U2019t be completed. (NSCocoaErrorDomain error 256.)
<unknown>: error: Unable to open NAAStore/Sources/NAAStoreModelAdapter/_Support/TaskSelectionDefinitionInfo+TaskSelectionDefinitionModel.swift: file is not readable or does not exist
<unknown>: error: Unable to open NAAStore/Sources/NAAStoreModelAdapter/_Support/EventInfo+EventModel.swift: file is not readable or does not exist
...

As you can see, most errors mention the config file, but some mention other files. Those other files do in fact exist:
$  ls -al "NAAStore/Sources/NAAStoreModelAdapter/_Support/TaskSelectionDefinitionInfo+TaskSelectionDefinitionModel.swift"
-rw-r--r--  1 me  staff  1707  6 Feb 15:16 NAAStore/Sources/NAAStoreModelAdapter/_Support/TaskSelectionDefinitionInfo+TaskSelectionDefinitionModel.swift
$ ls -al "NAAStore/Sources/NAAStoreModelAdapter/_Support/EventInfo+EventModel.swift"
-rw-r--r--  1 me  staff  751  6 Feb 15:16 NAAStore/Sources/NAAStoreModelAdapter/_Support/EventInfo+EventModel.swift

This command line produces the errors:
swift-format format --configuration ./swift-format.json --in-place --recursive --parallel .

This one does not:
swift-format format --configuration ./swift-format.json --in-place --recursive .

This morning I upgraded swift-format from 508.0.0 to 508.0.1 and I still see the errors.

I found an explanation in a closed bug, #421. In --parallel mode swift-format opens a lot of files all at once — and blows past the default maxfiles limit of 256.
Using something like:
ulimit -Sn 4096

in the session "fixes" the problem — until you exit the session (or reboot).
A fix that survives reboot is... more involved.

Tracked in Apple’s issue tracker as rdar://126948350

Hello,
Is there a workaround for this ? Right now this makes the --parallel option unusable on large projects, which kind of defeats its purpose.


LSTMs with Sequences for outputs

So I've been playing around with regenerative modeling using RNNs and I've been wondering the following:
Assuming an input of size (1000, 25, 15) where 1000 is the samples, 25 is the sequences per sample and 15 are the features per sequence. I am predicting the next sequence as output and it works well. Now if I wanted to predict further in the future I could feed the next prediction as an input and go on for as long as I want. My question is, could I train a model based on n_number of sequences as y_train? E.g instead of getting for outputs (1000, 1, 15), to get as output (1000, 25, 15) therefore training a model to predict a number of future sequences. I have already hacked something together that does that but not in the nicest of ways. Basically I train 15 models, one for each feature that all predict the next 25 outputs for that value and then I stitch them together. Does keras support a way of doing this without having to train a gazillion models each time? Thanks for your time.

Sounds like you want to use return_sequences=True. I don't know how if the provided loss functions can handle sequences automatically, otherwise you'd have to implement your own cost function that does that.

Yeah thanks. That was very helpful. I found a way to do something very similar to what I wanted to do. I'll try it out.

Please comment if you're successful. As have an identical use case and have been trying to debug how to set this up correctly.

I am also curious as to how to implement this.

Hey guys,
I did the code for this, and it worked very well. So this is how to do it.
Given 1000, 50, 24 input and 1000, 50, 24 outputs
output_features=X.shape[2]
model = Sequential()
model.add(LSTM(neuron_units, return_sequences=True, input_shape=(self.X_full.shape[1], self.X_full.shape[2])))
model.add(Dropout(0.2))
model.add(TimeDistributedDense(output_dim=output_features))
print("Output Units "+str(output_features))
model.add(Activation('tanh'))
model.compile(loss='mean_squared_error', optimizer='rmsprop')
return model

One question on your example. Why did you output 24 dim for your features. Are your 24i nput features lags of the variable your trying to predict and your 24 output features the next 24 observations of the variable or are you actually trying to predict 24 different variables simultaneously 50 periods into the future? Just curious as to what exactly you were able to be successful with?

My sample changed since last time, so 1000 is the number of samples, 50 is the number of sequences per sample and 24 is the number of features per sequence. I feed that in and get predictions on the next 50 sequences for all 24 of their features. The performance is really really good. It has managed to learn very complex signals and even managed to predict features that are otherwise set by a human(control signals).

Really curious what example you have with 24 features that need predictions. I can think of lots of examples where your input is (1000,50,24) and output is (1000,24,1) for example input features are 24 current economic indicators and output singular feature is next 50 gdp values. Are your predicting 24 separate time series that are not independent like server logs or stocks in the Dow Jones? Or do you really only care about the prediction for 1 of your 24 features are the rest are just correlated with the one you care about but are primaryily just used for inputs?

I get what your point is. My example is basically the behavior of a system/machine and everything is connected to each other. In more general cases, you may use it to predict the next frame from the previous frame which would obsiously be a very large amount of features. Also in generative modeling you feed all the outputs back to the inputs to hallucinate what comes next. So yeah, that's what I did.

@AntreasAntoniou Please close this, since it's not a bug and your problem was solved. Questions should be sent to the mailing list instead of the issue tracker.

@jfsantos For some reason I don't have access to the close button.

@AntreasAntoniou What did you use as the number of LSTM blocks in the hidden layer? Also can you share your whole code please?

@AntreasAntoniou , I am working on a similar problem. The main difference is that I am trying to use an input of (1000, 96, 1) to get the output of (1000, 8, 1), which means the number of time steps in input and output is different. In other words, I am trying to use the previous 96-time steps value to predict the next 8-time steps value. Is it possible to use the same approach to achieve this? I tried to run but it gives me the error:
Error when checking model target: expected activation_1 to have shape (None, 96, 1) but got array with shape (1000, 9, 1) .
Alternatively, I have another way to formulate this problem. I view the previous 96-time steps as one time step, and I use 96 as the number of features. Hence my input looks like (1000, 1, 96) and the output looks like (1000, 1, 8). I am not so sure about this, though.


Audio removal offset

Hello, I am experiencing the issue that all cuts made by auto-editor are slightly too long which always "eats up" the beginning of my sentence on a normal voice recording. I experience this when I export into Adobe Premiere and use the Command:
auto-editor test2.mp4 --export_to_premiere --frame_margin 5 --silent_threshold 0.04 --silent_speed 1.00
In the waveforms from the picture below it is clearly visible that all silent areas (highlighted) are slightly too long.

Maybe i have been overlooking something. Help is hugely appreciated.

Typically these weird cuts are caused by the program and premiere pro using different frame rates.
29.97 is the default fps value auto-editor choices for  Premiere Pro but you can change with framerate auto-editor uses by using this command:
auto-editor example.mp4 metadataOps --force_fps_to 24

Typically these weird cuts are caused by the program and premiere pro using different frame rates.
29.97 is the default fps value auto-editor choices for  Premiere Pro but you can change with framerate auto-editor uses by using this command:
auto-editor example.mp4 metadataOps --force_fps_to 24

This fixed the issue. My footage was 30 FPS and did not match the exported 29 FPS from auto-editor.
Thank you so much, you made my day! Unbelievable that this technique of editing video is not widely used.

This fixed the issue. My footage was 30 FPS and did not match the exported 29 FPS from auto-editor.
Thank you so much, you made my day! Unbelievable that this technique of editing video is not widely used.


Fixed font ligatures not rendering correctly on cursor movement in Win32

Related open issues: #12901
Related closed issues: #9181
Problem: font ligatures don't render correctly in the Win32 GUI-version of gvim even when set rop=type:directx is used. Setting guiligatures also doesn't make any difference. This leads to broken font ligatures when the cursor passes through them. It does not recover from this, and they remain broken until you re-render the whole buffer (e.g. by using Ctrl+L). See GIF below before fix.

Steps to reproduce/test:

Open any Win32 GUI-release of gvim
set guifont=Iosevka
set rop=type:directx
Notice font ligatures rendering correctly, until you pass the cursor through them.

Solution: the problem is that we only re-draw the current and previous character in gui_undraw_cursor and only have the special case for GTK when it comes to rendering ligatures. This PR enables gui_adjust_undraw_cursor_for_ligatures to also happen for Win32 GUI if guiligatures is setup correctly (all this does is expand the range of gui_undraw_cursor with ligature characters).
Here's a GIF of how it behaves after the fix:

ah, great, thanks!


fix: updated button style

Fixes #4754
Describe the changes you have made in this PR -
I have updated the style of Previous and Next button when they're disabled.
I have tried differentiating the active buttons with disabled buttons by updating their style.
Disabled buttons: Previous button and Next button on first page under Recent Circuits section.
Screenshots of the changes (If any) -
https://github.com/CircuitVerse/CircuitVerse/assets/132576984/ae457d3f-fe89-414b-b5b7-ea271f1075cf
Note: Please check Allow edits from maintainers. if you would like us to assist in the PR.

Hey @tanmoysrt Do I need to work more on this PR?

Hey @tanmoysrt Do I need to work more on this PR?

That time the CI was broken. Will check soon.


Add error capturing for plugins whose manifests we can't discover/generate

Summary
This issue captures work required to satisfy TODO number 4 in #587. When we fail to discover or generate a manifest for a plugin, and therefore are unable to display its npe2 metadata, we should capture the error in discovery. We should also ideally have easy access to aggregate information about all failing plugins.
Rationale: We know that there are consistently a significant number of plugins whose metadata we cannot retrieve. It's important for us to know why that is, and whether changes can be made to our workflow, or to the plugin itself that can address these failures. Not only is this critical for us to maintain a consistent level of coverage, but also so that we can (potentially) report to developers.
Intended Outcome
Save error messages from manifest discovery for each plugin.
How will it work?
We could write individual error messages to the cached information about a plugin, in a dedicated file alongside the plugin manifest or in an aggregate manifest_failures file. Decisions made in #620 will likely inform our decision here.

This issue can be closed by the work in #645. We write any errors in manifest discovery to the manifest file itself.


app passed NULL surface

There is some delay when the HiddenCameraService is started (please refer 1st and 2nd lines from below log).
Then after a while (about 5-10 seconds), the image is captured (pls refer 3rd line in the below log)
D/Camera: app passed NULL surface
I/Choreographer: Skipped 47 frames!  The application may be doing too much work on its main thread.
D/Image capture: 1376498
Device: Moto G4+

Then after a while (about 5-10 seconds), the image is captured (pls refer 3rd line in the below log)

This is because, in the source code of the sample apk, it is programmed to capture the image after 10 seconds. This is not a bug.😊


ember-getowner-polyfill 2.2.0

Gets us on a version of ember-factory-for-polyfill that doesn't depend on ember-cli-babel 5.x

Brain fart. This isn’t really needed.


Add a .flag_outliers method.

It'd be nice to have a quick way to flag individual time-series outliers. It should be an action that returns a copy of the existing Rainbow but with the ok array modified to reflect which points are outliers. It'd be good if it were robust to the presence of slowly-varying signals (like a well-sampled transit), so outliers could probably identified with some kind of sigma-clipping in the np.diff of each wavelength's light curve.
This might commonly be called before binning, to remove bad points from bins. Let's be careful the uncertainties get handled well.

Taking a crack at this one!

Added a simple flag_outliers feature in #166. Worked pretty great without needing to remove astrophysical signals first. The action only modifies the rainbow's 'ok' array, it does not mess with anything else in the rainbow/data.

I made a few tiny changes in #189 , including adding a inject_outliers to make it easier to test this.


Dream template GTmetrix report - picture gallery templates increase image file byte sizes

I tested mw1.1.13 Dream template on a test domain and ran a GTmetrix report as attached. The first 3 checks are graded F; the first two relate to image optimisation and the third to file ui.css being served via 2 urls, one with and one without the version parameter.
The images that are hugely scaled down and are listed for optimisation are the png images loaded in the company logo slider. The original assets are small in terms of byte size, but the sizes for the same images in the cache are much larger. For example the first image listed is the 'dribble' logo, the original png file 'partner3.png' is only 10KB file size. However the thumbnailed image in the cache increases to 95KB! I see that in template file userfiles/templates/dream/modules/pictures/templates/skin-1.php (and others) the dimension 993x350 are passed as parameters in the thumbnail function.
3 questions:

Do the picture gallery templates need to set the thumbnails so large at 993x350? Because increasing pixel size increases file byte size to the detriment of page load speed and SEO?

Any idea where the references to userfiles/modules/microweber/css/ui.css are not consistent? I can't see any evidence in the home page source, but maybe GTmetrix is checking across several pages. Sounds like a GTmetrix test on the WordPress Twentyseventeen theme flags up a similar issue.

The iconsmind.woff fonts file is a great resource of icons, however it adds a 1.1MB overhead that slows down page loading. Could the woff file be reduced in size maybe by using the woff2? Intial conversion test suggests that a woff2 file would be about 365KB which would be a huge saving.

GTmetrix-report-organic-living.uk.pdf

The same logo slider png images in the Q-theme are less than 10KB each.


What linux is best for strictly-netbeans

The detailed description I am having with my RHEL8 netbeans compile of a 2020 github GPL-3 repo is here: https://stackoverflow.com/questions/78775164/what-linux-os-will-permit-netbeans-to-update-a-currently-non-functional-java-app
I would surely be helped if I knew what flavor of linux strictly-netbeans and its related snaps works best on.

I have not tested the profiler with the Strictly NetBeans Snap package, and it looks as if it's not going to work. The native libraries for the NetBeans profiler require GLIBC version 2.34, yet the latest GLIBC in the Strictly NetBeans Snap package is version 2.27.
Below are the GLIBC versions required by the shared library that the profiler is trying to load:
$ objdump \
  --dynamic-syms \
  /snap/strictly-netbeans/current/netbeans/profiler/lib/deployed/jdk16/linux-amd64/libprofilerinterface.so \
  | grep GLIBC | sed 's/^.* (\(GLIBC_*[\.0-9]*\)) .*/\1/' | sort --unique --version-sort
GLIBC_2.2.5
GLIBC_2.3.4
GLIBC_2.4
GLIBC_2.14
GLIBC_2.34

And below is the GLIBC library in the core18 package used by the Strictly NetBeans Snap package:
$ grep libc6 /snap/core18/current/snap/manifest.yaml
    - libc6-dev=2.27-3ubuntu1.6+esm3
    - libc6=2.27-3ubuntu1.6+esm3

I'm not sure whether there's a way to get the profiler working in the Snap package. Perhaps I could upgrade to the core20 support package, but that might cause compatibility problems with the Strictly Maven and OpenJDK Snap packages to which it connects.
I recommend that you download the unconfined official release of NetBeans from the Apache website and run on any version of Linux that has GLIBC 2.34 or later. You can find the list for Ubuntu and Fedora in the README file of the OpenJDK Snap package.
You could also install the official NetBeans Snap package, which runs unconfined in classic mode using your local system libraries.
Are you installing the Strictly NetBeans Snap package for its security benefits, or for some other reason?

It is much harder to compile and run this JavaFX code than in 2022.  Apparently, I need better gtk pointers, access to GLIBC, maven, ant, openjdk, javafx-sdk, and perhaps some web services that have been deprecated.  I thought strictly-netbeans would solve some of these problems and improve debugging.  I had already tried off-the-shelf netbeans, which provided many of the same problems.  Maybe I have to go backward in netbean editions.  In 2022 the compile was smooth, bugless and provided a fine app!

If you're just trying to build the JavaFX application, I'm surprised that the NetBeans Profiler was invoked. In my experience, that is run manually to profile the performance of the running application.
I haven't seen the problems you're having with my own JavaFX applications in NetBeans. You might try starting with something simple like my "Hello, World" JavaFX project called hello-javafx to see whether you can build it in NetBeans using Maven. If that works, perhaps you can use it as a guide to simply your application's build process.


fire event when initialized

is there a way to check if the scrollbar has been initialized? I want to start a transition once the scrollbar is initialized and ready but can't find a proper way to do so.
Thanks,
Jürgen

The scrollbar is ready as soon as .init() is called.

thanks for clarifying!


Test using RocksDb rather than MapDb for models

Test feasibility and impact of using RocksDb rather than MapDb for "memory or disk" models.

RocksDB looks superior to MapDB:
Vocabulary Loading
MapDB
Words: 2 minutes 15 seconds
Terms: 2 minutes 56 seconds
Norms: 25 seconds
RocksDB
Words: 6 seconds
Terms: 9 seconds
Norms: 1 second
Going to work on converting all disk models to RocksDB now.


Make sure to close nshandle in ipvs.New

Signed-off-by: Jana Radhakrishnan<EMAIL_ADDRESS>

LGTM

LGTM


Dependency versions, Typescript and Vue 3.

If there's interest for onetech, I've been running twotech with Node 18 and dependencies as up to date as possible for some time now.
The two package.json files provide most of the required context, but I recall there were various breaking changes to Canvas, Webpack, Babel and more.

https://github.com/twohoursonelife/twotech/blob/master/package.json
https://github.com/twohoursonelife/twotech/blob/master/process/package.json

@mtklass is also kindly finishing up migrating the project over to Typescript and Vue 3 via this PR.
Would be happy to assist further or PR directly if there's interest.

@connorhsm I'm uncertain when I will get around to updating onetech due to my busy schedule. It will likely stay on Vue 2 unless there is some critical issue that requires upgrading.
Since @Kazetsukai is the true owner of this repo I'll defer to him on adding other maintainers if he wants.

Same situation here, too many side projects on the go at the moment to give this much attention these days. Happy to go either way, main consideration on my side would be stability since it is linked to from Jason's site.


Implement Basic CI

No e2e run as yet, until we have some in place.

This is fixed now, just needs the openapi PR merged first
Run swagger validate openapi.yaml
open openapi.yaml: no such file or directory
Error: Process completed with exit code 1.

ok, I guess we need to park this one until some code is in :)

added the development branch

@dlorenc / @bobcallaway  can we ship this one, we don't have coverage of the development branch at present?

the failure is a follow up commit with no sig and you can't see to retroffix (likely a bug with the bot)


Split non-gRPC types from googleapis-common-protos

Note: I will not squash these two commits to preserve the diff.

Note: CI failures are expected because the googleapis-common-protos-types gem is not yet on rubygems.

@landrito Sure, I can do that (so hopefully CI will pass on the merged commits).


Bonk still exists after finishing the map (TM2, maybe TM2020?)

You can see this bug in this clip: https://streamable.com/5nzqnz
It always happens on TM2 no matter what, but on TM2020 I am not exactly sure.

maybe you can use this to detect if a player is finished?


Docs - Unreliable calculation of next state

components: documentation
reactstrap version #8.0.0

What is happening?
In many places throughout the documentation, it seems the examples provided are unreliably calculating the next state.
For example in the Fade component:
    toggle() {
        this.setState({
            fadeIn: !this.state.fadeIn
        });
    }

React's relevant documentation: https://reactjs.org/docs/state-and-lifecycle.html#state-updates-may-be-asynchronous
What should be happening?
I would expect the code sample to look like in the Modal component:
  toggle() {
    this.setState(prevState => ({
      modal: !prevState.modal
    }));
  }

I hope I'm not missing something here...

FWIW #1572 would negate this issue :)

Closing as fixed


Update UI dependencies

We should ensure our UI dependencies are as up to date as possible, including the version of Ember that we are using, before any substantial UI development. Most of our dependencies are about 2 years old.
This is not a blocker for preparing the codebase for transfer.

Closed by https://github.com/eclipse-pass/pass-docker/pull/317


Bump jetty from 9.4.46.v20220331 to 9.4.53.v20231009

What changes are proposed in this pull request?
Upgrading jetty from 9.4.46.v20220331 to 9.4.53.v20231009 fixes security issues.
Why are the changes needed?

The jetty version 9.4.46.v20220331 has disclosed a lot of CVEs, it needs to be upgraded

@gp1314 A new version https://github.com/jetty/jetty.project/releases/tag/jetty-9.4.54.v20240208 has been released, how about bumping to the newer version?


[old]Fix "The Protocol whitepaper" and "Khaos"

I fixed "The Protocol whitepaper" and "Khaos".
changes

Fixed to the latest contents. Because contents of the "new-docs" are old.

I created new one to resolve conflict. new pr


Boundary Text Is Not Drawing Correctly

From @abouffard on April 8, 2016 7:26
This might not be an issue with the editor, but was noticed when testing.
The unique designation text is not being drawn correctly.  The two strings should be drawn on opposing sides of the line.

Here is the boundary guidance from 2525:

Copied from original issue: ArcGIS/military-symbol-editor-addin-wpf#27

From @csmoore on April 8, 2016 12:5
@abouffard That is definitely an issue with the data - can you move this issue to https://github.com/Esri/military-features-data ( I would guess it already exists there - ex. these look similar:  https://github.com/Esri/military-features-data/issues/66 & https://github.com/Esri/military-features-data/issues/174 )
But if even you are unsure - then that tells me we definitely need to add a warning in the contributing.md and readme to let users know to log "symbols-drawing-wrong-on-the-map" issues to https://github.com/Esri/military-features-data

Closing. Issue is being tracked here, https://github.com/Esri/military-symbology/issues/27.


Client Allocation Request for: Beijing Blue Qiyuan Technology Ltd.

Client Allocation Questions
Core Information

Name: Beijing Blue Qiyuan Technology Ltd.
Website / Social Media: http://www.tpjx.org/
Region: Greater China
DataCap Requested: 50TiB
Addresses to be Notarized: f3qoc4rldxutogaa72hbnml3rqh6xlbyy4m562l5jwumyyfdqqupen446gh5gwkra5xbcjitgrrruemrsxr4za
Notary Requested: MRJAVAZHAO

@uupptoday Please subscribe to notifications for this Issue to be aware of updates. Notaries may request additional information on the Issue.

Please provide the following materials.
if you are an organization, Please describe your organization, such as established time, business scale, social media accounts&follwers, the number of employees, users volumn and business license (could be sent by email,<PHONE_NUMBER>@qq.com); if you are an individual, please provide name, date of birth, working company and scale, employment certificate, social media accounts&follwers, and ID card (can be sent by email,<PHONE_NUMBER>@qq.com);
When did you start learning about Filecoin? Please give a description about the projects you have participated in ? What do you want to get from Filecoin? Any suggestions or expectations for the Filecoin Network?
Is there any law risk? What percentage of questions are yours?
How about your data volume, source and later planning? Please describe the type, format, source, storage capacity, publicity (and if data could be public, how can others retrieve it?) of the data to be stored in Filecoin.
In which area do you plan to store you data? How many miners do you want to find ? Please list the miner ID. How about the proportion of the storage for each miner? What are the requirements about miners? At last, please state your redundancy plan.
Do you agree to disclose transaction information? If you get DataCap, please make the transaction information public on the Issue in time.

Hi,@MRJAVAZHAO
Our company assists enterprises to find suitable candidates for selection and research through comprehensive analysis of talents from multiple perspectives, such as specialty, profession, life circle and integrity.
Currently, the company is involved in registering and parsing information about the identity, likes, and duration of a person or organization on the Internet through distributed digital identities (diDs) through decentralized, verifiable digital identifiers.
Incorporation Date: (1year)
Team Member: ＜50
Business Scope: world
Number of Users: more than 100 business users
Official website: http://www.tpjx.org
Project: Talent information big data project and Traceability of industrial chain information.
No previous exposure to IPFS/Filecoin.
There is no legal risk.
The data we'll store in Filecoin includes Pictures, videos, documents, logs, etc.
Our data volume is more than 1000TB, mainly from Internet public data, enterprise docking data and independent analysis data, etc.
Along with the development of metasverse, we will also track the virtual world talent information, creative contents copyright, virtual transactions and other metasverse models.
Data is public.
We prefer to store our data in China, but haven't decide who is the best miner for us.
We plan to store 3-5 backups, miners are expected to have worked for Filecoin in a long time .
Yes.

Request Approved
Your Datacap Allocation Request has been approved by the Notary
Message sent to Filecoin Network

bafy2bzacedt5qlde5b3weftgpiz4qxkgz36sy7ij54eoecwslxd55emvkbnvm

Address

f3qoc4rldxutogaa72hbnml3rqh6xlbyy4m562l5jwumyyfdqqupen446gh5gwkra5xbcjitgrrruemrsxr4za

Datacap Allocated

2 TiB

You can check the status of the message here: https://www.atpool.com/zh/chain/msg/bafy2bzacedt5qlde5b3weftgpiz4qxkgz36sy7ij54eoecwslxd55emvkbnvm-1320279


Fixed a moving window issue. Added OnLoad Action because there are settings that need to be accessed only once.

@tig Can you please tell me which of the two situations you intended?
a) "This should go on the bottom of the same top-level!"
b) "This should go on the bottom of another top-level!"
If it is a) you can attach the label to the window, so there is no problem.
If it is b) you cannot attach the label to the window because the label is outside the window's limits, so the window cannot be responsible for repainting it, so the label must be assigned to another top-level.

@tig Can you please tell me which of the two situations you intended?
a) "This should go on the bottom of the same top-level!"
b) "This should go on the bottom of another top-level!"
If it is a) you can attach the label to the window, so there is no problem.
If it is b) you cannot attach the label to the window because the label is outside the window's limits, so the window cannot be responsible for repainting it, so the label must be assigned to another top-level.

@migueldeicaza  actually did that, but I've spent a bunch of time on StatusBar and the whole 'position at bottom' problem, so I now have clarity. This PR is NOT ready:
https://github.com/migueldeicaza/gui.cs/pull/372
The summary is: Windows Terminal & ConEmu support vertical resize. cmd.exe does not. I doubt curses or Net do either. But for those that do we should provide two options:

The behavior currently in demo.c where "This should go on the bottom" is tied to win.
The behavior currently in StatusBar.c where it tracks to Application.Driver.Rows -1.

In my next StatusBar PR, I introduce a Parent property. If Parent is set (e.g. Parent = win) we get behavior #1 (last line of parent view).
If Parent is null, then the StatusBar sticks to bottom of console window. Not sure why anyone would really want this, but it mimics current behavior.
Make sense?

I think it's a good idea. I will try to dedicate myself a little to handling the mouse in linux because it behaves competently differently from Windows. It is impossible to drag on windows, as well as clicking on the menu. It really fails.


Fixed issues with Layout

Fixes issues with Login and Feedback Page

Creating a new pull request from a separate branch!

Separate branch works.


Googapi error "project 'x' has no network named "default"., badRequest

Rancher versions:
rancher/rancher
Docker version: 17.03.2-ce
Operating system and kernel: cos - 4.14.22+
Type/provider of hosts: GKE
Setup details: single node rancher
Environment Template: Kubernetes
Steps to Reproduce:
With a GKE cluster that has a non-standard vpc setup.

Click the 'Add Cluster' in Rancher.
Select GKE.
Upon completion of details click 'Save'.

Results: You will be presented with this error:

Googleapi: Error 400: project "X" has no network named "default"., badRequest

This might be a feature request I guess. The ability to choose the network for the cluster.

Agreed.  Makes it impossible to use with a Shared VPC model.

please enable IAM Service Account Credentials API in gcp.
It worked for me.

@tfiduccia can we request what network to use when creating a cluster?

@deniseschannon - yes we allow the network to be chosen now.  We have added it as a drop-down in the Cluster Options section for GKE


[Bug] Intellisense stops working after a while from time to time

Intellisense stops working after a while from time to time in TypeScript files: autocomplete and squiggles not being shown.

VSCode Version: 1.10.2
OS Version: Windows 8.1 x64

Steps to Reproduce:
Don't know how to reproduce and what are the factors that make it happen. Restarting the IDE helps, but the issue keep being reproduced from time to time. Maybe I may provide some sort of dumps or telemetry?

Firstly what language are you working with? if you import/require something into the scope when using JS/TS  - Code tries to supply typings for it in the background and rebuilds suggestions accordingly. it can take some time. it can also fail somewhere in between and freeze Intellisense. You can try to start a new sample project and step-by-step build it up while checking every step whether Intellisense is still working...

@Spown Thanks for your response. As I mentioned in the initial message, I use TypeScript (2.2.1). I'm afraid the proposed way of catching the bug is not suitable for me since it looks very time-consuming and doesn't guarantee any positive result in catching the bug. But if I'll find a more clear and/or simple way to reproduce I will post it here of course.

there is also devtools in the help menu. so when it happens next time - you can look into the console and see whether there were any fatal errors...

@Spown Could you give the insiders build a try? (https://code.visualstudio.com/insiders) That is currently close to the upcoming release and it would be great to know if you see the problem with that too.
If that doesn't help, try starting with --disable-extensions to rule out any extension is causing this.

@chrmarti are you sure you're addressing the right person?

Doh! I meant to ask @Deilan (see my comment above). Thanks.

@Deilan are you experiencing the same issue described here?

@chrmarti I'll test it when I have some time for that.
@bitliner Looks similar. Yes, I experience infinite Loading pop-ups upon using Ctrl+Space, absense of code autocompletion and squiggles not being shown.

@chrmarti with --disable-extensions nothing changes.

@Deilan @bitliner Could you enable the TS Server's logging in the settings with "typescript.tsserver.log": "verbose" and then restart VSCode? Once the problem shows, open the log file with the command TypeScript: Open TS server log file and attach it here. (Note that you will need the insiders build for this to work.)

Closing as we need more information to investigate this.
Please try collecting the log as @chrmarti described using the latest VSCode release. Make sure to run code with extensions disabled by using the --disable-extensions flag


Ip sharing

Tests to come

Closes #261

Coverage decreased (-1.3%) to 75.596% when pulling 921b1d9c523232ffc6d778a0aad55a94f375d54d on eatonphil:ip-sharing into cbe2cf17d869ac158d404c430a5cea4c06c1fe50 on linode:master.

Coverage decreased (-0.3%) to 75.95% when pulling e497c7b95c80085ab6b3f8aaceaeca011f5e7f6d on eatonphil:ip-sharing into fd5fbe9302a098b6f2ee914cc8c0ae8c529bad2d on linode:master.

Coverage decreased (-0.3%) to 75.95% when pulling e497c7b95c80085ab6b3f8aaceaeca011f5e7f6d on eatonphil:ip-sharing into fd5fbe9302a098b6f2ee914cc8c0ae8c529bad2d on linode:master.

Manually tested, it works, but like others has no indication the save went through.  We'll need to tabulate all the places where a save occurs and we want a save indication to happen.

Thank you!


Add new Rails/ForeignKeyName cop

https://rails.rubystyle.guide/#meaningful-foreign-key-naming

It's been a while 😄
@pirj, thank you for suggestions! I addressed all of them, please take a look.

@fatkodima Do you think it makes sense to run the new cop against https://github.com/eliotsykes/real-world-rails to check if there are errors, and check for false positives?
I can do this for you, as it's a tedious task.
@koic Will you please take a look?

Do you think it makes sense to run the new cop against https://github.com/eliotsykes/real-world-rails to check if there are errors, and check for false positives?

👍  I ran it on gitlab's codebase. Got 1 error, fixed it. For other migration files - seems like is working as expected.

One concern I have about this cop is that once introduced, it will start flagging old migrations.

I added a new option to be able to ignore old migrations. I think, it will be also useful for other existing cops, like AddColumnIndex or CreateTableWithTimestamps, etc.

Updated.


Adding a rule for ignoring the target directory from the build

Reasons for making this change:
I think adding an ignore for the target directory produced by the build would be very useful for others, just like I find it useful myself.

i am tired.working 2 days and no sleep.ok.i want rest
On Thu, Feb 9, 2017 at 11:41 AM, mr brightside<EMAIL_ADDRESS>wrote:

@sepatus approved this pull request.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/github/gitignore/pull/2276#pullrequestreview-20925288,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AX9HIxMlr1uLNS7B6KiiL6DfHHFSh5qtks5raorngaJpZM4L7PPE
.

target/ is the (default) output directory, when building Java-Sources with Maven. Plain Java (javac) has no target directory; unless you explicitly chose to specify it, for your project.
--> This should not be in here!
If you are using Maven, please just use Java.gitignore in combination with Maven.gitignore (which already contains target/).

Seconding what @drothmaler said - this is covered by Maven.gitignore.
Closing this out to avoid unnecessary duplication.

I didn't see there was a Maven.gitignore. Sorry for you time.


Adding page borders /margins

Hey @agentcooper thanks for putting together this sample, it's been very helpful. I'm trying to add back page borders and other margin/padding, but having trouble adjusting the highlight layer to accomodate.  How would someone compensate for these margins in the highlight layer?

Maybe adjust it in https://github.com/agentcooper/react-pdf-annotator/blob/master/src/style/pdf_viewer.css#L8?


Fills will be animated if defined as a path-based pattern. see this JSFiddle :)

Please define your problem or issue as clear as possible.
For a problem, please fill the following:
Vivus version: all
Browser: all
Steps to reproduce it:

A standard fill won't get animated, but...
Convert the fill to a path-based pattern (easy, see below and see the jsFiddle) and it will be nicely animated by Vivus

note: although changing the fill method is relatively easily done enough by hand, vivus has the capability to be used by regular people (not SVG experts) for whom this task is really too much.  This capability could be added to vivus to automatically do the conversion for them, see JSFiddle and below for what is involved.
JSFiddle link (or similar platform):
http://jsfiddle.net/davea0511/Lg376abm/
No personal website will be allowed, only sandboxed platform where the code is isolated and can be hacked.
[note]
I apologize for not doing the parsing code to make this automatic in vivus.    I just kind of fell into this solution and thought it worth sharing.  To do it all you need is to change the fill to work like so:
<pattern id="pathFill1" patternUnits="userSpaceOnUse" width="2" height="30" >
    <path stroke=[fill color] d="M 1,0 l 0,30" stroke-width="2" class="SnupXuXl_0"/>
</pattern>
<path fill="url(#pathFill1)" ...>

Pattern notes:

I used a pattern height of 30, but if set to something big like 200 the animation will be one long fill instead of looking like closing blinds.
I used a pattern width of 2, but it doesn't matter so long as the path stroke origin is half of the width, and the stroke-width must be the same as the pattern width, or more.  Perhaps a wider width will be easier on the browser?  like width="100", d="M 50 ...", stroke-width=100? I don't know.  Just a thought.
Combinations of pattern sizes and path stroke definitions create some pretty cool patterns, plaid for example, if you wanted that, or diamonds or dots.  Not sure how useful this is ... but there it is.

[/note]

Note of course this only works for flat colors ... no gradients or patterns of course ... but again tweaking the pattern routine might be able to do this.  Above my head.

Hi there,
Thanks for your detailed demo. It's pretty promising and there's a lot of potential. I wasn't aware of pattern to be part of the original SVG specs. I try to find a way to integrate it to make a seamless as possible. However I hit a little problem when it comes to get the color of the element to animate. The fill color can be set via a CSS class and that make it more difficult to get. But I'll try to investigate to find a solution.
Having that kind of fill animation would be a nice plus :)

Hi @maxwellito, did you ever get around to implement something based on this? I would be very interested if you did!

Hi @Lauwisme
Sorry I didn't provided any update there. When the issue was created I played a lot with it but couldn't find a way to implement it correctly that work with most use cases :(


Need a mechanism to automatically update cross-repo

As we are moving to multi-repo, we have a lot of changes that require changes to other repos. For example, if we update the builder image in istio/tools, we need to trigger an update in test-infra to use the image. If we update istio/proxy, we need to update the version we use in istio/istio.
Currently this is almost entirely manual, which is pretty painful.
I believe we had some process that would do daily updates to proxy, but it has been broken/disable for months. We may be able to reuse some functionality there.
These can be triggered daily or in postsubmit, not sure which is better.
cc @geeknoid

Right now there are three ways dependencies are defined:

go.mod - can be updated with go get repo@sha
istio.deps - our homegrown dependency management. Could update with jq probably
Nothing, just git clone at master - we should never do this

One possible design:
We have some autoupdate.yaml file like
- repo: istio/istio
  deps:
    - repo: istio/cni
      type: istio.deps # go.mod or  istio.deps
      source: master # branch
      freq: every # every commit, daily, weekly, etc
    - repo: istio/pkg
      type: go.mod
      source: master
      freq: daily

And then some periodic job that goes through and triggers a bunch of PRs to relevant repos updating different components. Note -- it should not batch multiple updates into one PR, so we can merge independantly. Prow takes care of testing PRs merged together.
I think this would work, my only concern is reinventing the wheel... If there is a better way to do this that would be prefered.
For the go.mod updates there are certainly existing solutions. I've tried https://dependabot.com/, but its not viable for a couple reasons: you cannot whitelist what modules to update, and it does not do go mod tidy.

Resources:

A tool we use that does some PR stuff: https://github.com/istio/test-infra/tree/master/toolbox/githubctl
Cross repo updates from k8s: https://github.com/kubernetes/publishing-bot
Prow cherry pick code: https://github.com/kubernetes/test-infra/tree/master/prow/external-plugins/cherrypicker

An automated PR generation (from master of common-tools) to the various repos under management would be really helpful.  I'll take a look at the 3 options once 1.4 is done baking for the common-files case.

done by automator